【SGX系列教程】（四）Intel-SGX 官方示例分析(SampleCode)——LocalAttestation

    下面将给出一些sgx源码包中的示例LocalAttestation分析，从中学习本地认证和SGX的基本使用方法：关于 SGX 开发运行环境的搭建可参考之前的一篇博客：【SGX系列教程】（一）。

一.LocalAttestation原理介绍

1.1本地认证原理

    本地认证是一种允许两个在同一台机器上运行的SGX实例（Enclave）相互认证（也就是一台机器上的两个enclave互相认证），确保它们都在可信环境中运行，并且它们的签名和测量值（MRENCLAVE和MRSIGNER）符合预期。这一过程无需依赖外部的可信第三方（如远程认证中的IAS服务），可以高效地验证在本地运行的两个Enclave的可信性。

1.2 本地认证基本流程

1.初始化

• 准备工作：在进行本地认证之前，需要确保系统上安装了英特尔SGX驱动和SGX SDK，并创建和签署了两个至少包含认证代码的Enclave。

2.创建会话

• 会话请求：一个EnclaveB（称为请求者）启动会话请求(1)，通过指定的本地认证API向另一个EnclaveA（称为响应者）发送认证请求。
• 会话处理：响应者接收到请求者的会话请求后，生成会话密钥，并准备响应。

3.生成认证报告

• 认证报告生成：请求者和响应者各自生成包含测量值（MRENCLAVE和MRSIGNER）、会话密钥等信息的报告REPORT。此报告用于证明Enclave的身份和状态。
• 认证报告交换：请求者和响应者交换各自生成的认证报告。

4.验证认证报告

• 验证报告：请求者和响应者分别验证对方的认证报告。这一步包括检查报告中的测量值、签名情况和认证会话密钥。
• 验证MRENCLAVE：验证对方Enclave的测量值（MRENCLAVE），确保其为预期的可信代码。
• 验证MRSIGNER：验证签名者的测量值（MRSIGNER），确保其由受信任的签名者生成。
• 验证会话密钥：确保会话密钥的正确性，用于后续的安全通讯。

5.交换密钥并通信

• 密钥交换：交换经过验证的会话密钥。
• 安全通信：一旦认证成功，请求者和响应者可以使用协商好的会话密钥进行安全通信，该密钥用于加密和解密传输的数据，确保数据传递的机密性和完整性。

总结：Intel SGX本地认证的步骤主要包括以下几个关键步骤：

• 两个Enclave初始化并准备各自的会话请求和响应。
• 请求者向响应者发起会话请求，双方生成并交换认证报告。
• 验证报告的真实性和可信度，确保双方的Enclave环境是可信的。
• 交换会话密钥，建立安全的通信渠道。

    以上这些步骤确保了两个在同一台机器上运行的Enclave可以安全、高效地相互认证，从而在本地保护敏感数据和计算过程。

1.3 本地认证核心原理

   就是响应方EnclaveA生成MAC值并返回给请求方，MAC值是由一个报告密钥生成，这个密钥只对目标EnclaveＢ和相同平台的EREPORT指令可见。当EnclaveＢ收到REPORT信息之后，调用EGETKEY指令来获取密钥，用来计算MAC值，进而将重新计算的MAC值和收到的REPORT的MAC值进行比较（核心思想：验证MAC值），来确认EnclaveA运行在相同平台之上。当可信硬件部分得以证实之后（也就是说MAC值验证的是硬件可信），EnclaveＢ在通过REPORT中的信息认证EnclaveA的身份。最后EnclaveA再以同样的方式认证EnclaveＢ的身份，完成双向互认。

二.源码分析

2.1 README

---------------------------
The project aims to demo SGX local attestation flow. 
------------------------------------
How to Build the Sample Code
------------------------------------
1. Install Intel(R) Software Guard Extensions (Intel(R) SGX) SDK for Linux* OS
2. Enclave test key(two options):
    a. Install openssl first, then the project will generate a test key<EnclaveInitiator_private_test.pem>/<EnclaveResponder_private_test.pem> automatically when you build the project.
    b. Rename your test key(3072-bit RSA private key) to <EnclaveInitiator_private_test.pem>/<EnclaveResponder_private_test.pem> and put it under the <EnclaveInitiator>/<EnclaveResponder> folder.
3. Build the project with the prepared Makefile:
        a. Hardware Mode, Debug build:
		$ make
        b. Hardware Mode, Pre-release build:
		$ make SGX_PRERELEASE=1 SGX_DEBUG=0
        c. Hardware Mode, release build:
		$ make SGX_DEBUG=0
        d. Simulation Mode, Debug build:
		$ make SGX_MODE=SIM
        e. Simulation Mode, Pre-release build:
		$ make SGX_MODE=SIM SGX_PRERELEASE=1 SGX_DEBUG=0
        f. Simulation Mode, Release build:
		$ make SGX_MODE=SIM SGX_DEBUG=0
        g. Use Local Attestation 2.0 protocol, Hardware Mode, Debug build:
        $ make LAv2=1
           Note: Local Attestation 2.0 protocol will be used if 'LAv2' is defined.
When build is successful, you can find executable binaries in "bin" sub-folder.
------------------------------------
How to Execute the Sample Code
------------------------------------
1. Install SGX driver and PSW for Linux* OS
2. If you want to try local attestation flow from two process, you can goto "bin" sub-folder
   a. run "./appresponder".
      It would launch a process to act as local attestation responder.
   b. run "./appinitiator"
      It would launch a process to act as local attestation initator.
3. If you want to try local attestation flow from one process, you can goto "bin" sub-folder and run "./app"

------------------------------------
How to Get Signed Enclave's MRSIGNER
------------------------------------
1. Install Intel(R) Software Guard Extensions (Intel(R) SGX) SDK for Linux* OS
2. Execute blow command to get your signed enclave's MRSIGNER: 
    <SGX_SDK Installation Path>/bin/x64/sgx_sign dump -enclave <Signed Enclave> -dumpfile mrsigner.txt
3. Find the signed enclave's MRSIGNER in the mrsigner.txt(mrsigner->value:)

    该示例的主要功能是测试enclave本地认证功能，根据上面README中的内容总结一下LocalAttestation的执行步骤如下：

2.1.1 编译流程

1. 首先需要安装SGX sdk，以及等等对SGX的支持测试，具体可参考之前的一篇博客：【SGX系列教程】（一）；
2. 安装openssl，目的是为enclave.so生成签名私钥：

openssl genrsa -out Enclave/Enclave_private_test.pem -3 3072

3. 确保sdk路径生效（source），基本在安装sdk时会指定安装路径为：/opt/intel/sgxsdk；
4. 使用Makefile构建工程：
   • 硬件模式, Debug build（通常默认选择这个）:
     make
   • 硬件模式, Pre-release build:
     make SGX_PRERELEASE=1 SGX_DEBUG=0
   • 硬件模式, Release build:
     make SGX_DEBUG=0
   • 仿真模式, Debug build:
     make SGX_MODE=SIM
   • 仿真模式, Pre-release build:
     make SGX_MODE=SIM SGX_PRERELEASE=1 SGX_DEBUG=0
   • 仿真模式, Release build:
     make SGX_MODE=SIM SGX_DEBUG=0
   • 使用 2.0 认证协议, 硬件模式, Debug build::
     make LAv2=1

2.1.2 执行流程（双进程执行 or 单进程执行，在后面执行部分有展示效果）

1. 在Linux系统下安装SGX驱动和PSW（具体可以参考系列教程一）；
2. 可以通过两个进程进行本地认证流程，进入bin子文件夹：
   a. 运行 ./appresponder: 这将启动一个进程，使其充当本地认证响应者。
   b. 运行 ./appinitiator: 这将启动一个进程，使其充当本地认证发起者。
3. 如果您想通过一个进程进行完成全部本地认证流程，进入bin子文件夹直接运行 ./app。

2.1.3 如何获取已签名的Enclave的MRSIGNER

1. 安装SDK，适用于Linux操作系统。
2. 执行以下命令以获取已签名的Enclave的MRSIGNER：

<SGX_SDK Installation Path>/bin/x64/sgx_sign dump -enclave <Signed Enclave> -dumpfile mrsigner.txt

3. 在文件mrsigner.txt中找到已签名的Enclave的MRSIGNER（mrsigner->value:）(找到 mrsigner->value: 字段，即为签名该Enclave的签名者的测量值)

   注意，这里的<Signed Enclave>指的是编译之后针对每个enclave生成的签名文件，通常是.signed.so 或 .signed.dll 扩展名（具体取决于目标平台）。这里是在bin目录下生成的libenclave_initiator.signed.so和libenclave_responder.signed.so两个文件。
因为分别执行下面两个命令，为initiator和responder两个enclave分别生成相应的签名者信息文件：

// 1.为initiator enclave生成initiatormrsigner.txt
/opt/intel/sgxsdk/bin/x64/sgx_sign dump -enclave ./bin/libenclave_initiator.signed.so -dumpfile initiatormrsigner.txt

// 2.为responder enclave生成respondermrsigner.txt
/opt/intel/sgxsdk/bin/x64/sgx_sign dump -enclave ./bin/libenclave_responder.signed.so -dumpfile respondermrsigner.txt

   生成成功会输出Succeed.，并在目录下面会生成如下两个文件，分别代表两个enclave的签名信息：

然后需要将mrsigner->value:值分别copy到程序代码中以使用真实的签名者测量值（相当于公钥）：

   通过上述步骤，可以成功生成并替换已签名的Enclave的MRSIGNER信息。

2.2 重点代码分析

    SGX工程的整个构建流程在之前的文章中已经给出给出了详细教程：【SGX系列教程】（二）第一个 SGX 程序: HelloWorld，因此在此处仅给出部分重点代码分析，主要讲清楚enclave如何实现本地认证，其他通用代码不做展开分析。

2.2.1 App文件夹

2.2.1.1 App/App.cpp

#include <stdio.h>
#include <map>
#include "sgx_eid.h"
#include "sgx_urts.h"
#include "EnclaveInitiator_u.h"
#include "EnclaveResponder_u.h"
#include "sgx_utils.h"

// 定义信任域（Enclave）的名称
// 定义两个信任域ID，ENCLAVE_INITIATOR_NAME 和 ENCLAVE_RESPONDER_NAME 分别代表发起者和响应者的已签名共享库文件
#define ENCLAVE_INITIATOR_NAME "libenclave_initiator.signed.so"
#define ENCLAVE_RESPONDER_NAME "libenclave_responder.signed.so"

// 定义两个Enclave ID，分别用于发起者和响应者Enclave
sgx_enclave_id_t initiator_enclave_id = 0, responder_enclave_id = 0;

int main(int argc, char* argv[])
{
    int update = 0;                 // 定义更新标志
    uint32_t ret_status;            // 定义返回状态
    sgx_status_t status;            // 定义SGX状态类型
    sgx_launch_token_t token = {0}; // 定义启动令牌，并初始化为0
	// 避免未使用参数警告，argc和argv被标记为void
    (void)argc;
    (void)argv;
    // 加载发起者和响应者enclave
    if (SGX_SUCCESS != sgx_create_enclave(ENCLAVE_INITIATOR_NAME, SGX_DEBUG_FLAG, &token, &update, &initiator_enclave_id, NULL)
        || SGX_SUCCESS != sgx_create_enclave(ENCLAVE_RESPONDER_NAME, SGX_DEBUG_FLAG, &token, &update, &responder_enclave_id, NULL)) {
        // 如果加载Enclave失败，打印错误信息并进入销毁流程
        printf("failed to load enclave.\n");
        goto destroy_enclave;
    }
    printf("succeed to load enclaves.\n");  // 如果成功加载，打印成功信息
    
    // 使用发起者信任域创建ECDH会话，会话对象为响应者信任域
    status = test_create_session(initiator_enclave_id, &ret_status);
    if (status != SGX_SUCCESS || ret_status != 0) {
        // 如果会话创建失败，打印错误信息并进入销毁流程
        printf("failed to establish secure channel: ECALL return 0x%x, error code is 0x%x.\n", status, ret_status);
        goto destroy_enclave;
    }
    printf("succeed to establish secure channel.\n");
    // 如果会话创建成功，打印成功信息

    // 测试发起者信任域和响应者信任域之间的消息交换
    status = test_message_exchange(initiator_enclave_id, &ret_status);
    if (status != SGX_SUCCESS || ret_status != 0) {
        // 如果消息交换失败，打印错误信息并进入销毁流程
        printf("test_message_exchange Ecall failed: ECALL return 0x%x, error code is 0x%x.\n", status, ret_status);
        goto destroy_enclave;
    }
    printf("Succeed to exchange secure message...\n");
    // 如果消息交换成功，打印成功信息

    // 关闭ECDH会话
    status = test_close_session(initiator_enclave_id, &ret_status);
    if (status != SGX_SUCCESS || ret_status != 0) {
        // 如果关闭会话失败，打印错误信息并进入销毁流程
        printf("test_close_session Ecall failed: ECALL return 0x%x, error code is 0x%x.\n", status, ret_status);
        goto destroy_enclave;
    }
    printf("Succeed to close Session...\n");
    // 如果关闭会话成功，打印成功信息

destroy_enclave:
    sgx_destroy_enclave(initiator_enclave_id);
    sgx_destroy_enclave(responder_enclave_id);
    // 销毁发起者和响应者信任域（Enclave）

    return 0;
    // 主函数返回0，表示正常结束
}

程序解释：

• 加载enclave: sgx_create_enclave，enclave API，函数用于加载Enclave文件，并初始化发起者和响应者的Enclave实例；
• 创建会话: test_create_session，ECALL函数，用于创建ECDH安全会话，发起者（Initiator Enclave）需要与响应者（Responder Enclave）建立一个安全会话。
• 消息交换：test_message_exchange，ECALL函数，用于在发起者和响应者之间进行消息传递。
• 关闭会话：test_close_session，ECALL函数，用于关闭之前建立的安全会话。
• 销毁Enclave：sgx_destroy_enclave，enclave API，函数用于销毁发起者和响应者的Enclave实例。无论前面的操作是否成功，最后都会执行销毁步骤，确保资源被正确释放。

    总的来说，App.cpp代码用于演示Intel SGX中本地认证（Local Attestation）的基本过程，包括加载Enclave、建立会话、消息交换和关闭会话。每一步都使用了SGX提供的API，并结合错误处理机制，确保在失败时能正确退出并释放资源。

2.2.1.2 App/UntrustedEnclaveMessageExchange.cpp

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include "sgx_eid.h"          // 用于SGX Enclave ID定义的头文件
#include "error_codes.h"      // 自定义错误码的头文件
#include "datatypes.h"        // 自定义数据类型的头文件
#include "sgx_urts.h"         // 用于SGX User Runtime库的头文件
#include "UntrustedEnclaveMessageExchange.h" // 非受信任部分的消息交换头文件
#include "sgx_dh.h"           // 用于Diffie-Hellman密钥交换的SGX头文件

#include "fifo_def.h"         // FIFO定义文件
#include "EnclaveResponder_u.h" // 自动生成的Enclave Responder的未受信部分头文件

// 声明外部变量 responder_enclave_id，用于存储响应者Enclave的ID
extern sgx_enclave_id_t responder_enclave_id;

/* 函数描述: 这是发起者Enclave获取响应者Enclave的ECDH消息1和会话ID的OCALL接口
 * 参数描述:
 *      [输入，输出] dh_msg1: 指向ECDH消息1缓冲区的指针，这个缓冲区在发起者Enclave中分配，并由响应者Enclave填充
 *      [输出] session_id: 指向由响应者Enclave分配的会话ID的指针
 * */
extern "C" ATTESTATION_STATUS session_request_ocall(sgx_dh_msg1_t* dh_msg1, uint32_t* session_id)
{
    sgx_status_t ret;
    uint32_t retcode;
    // 调用 session_request 函数，获取来自响应者Enclave的ECDH消息1和会话ID
    ret = session_request(responder_enclave_id, &retcode, dh_msg1, session_id);
    if (ret != SGX_SUCCESS || retcode != SGX_SUCCESS)
        return ATTESTATION_ERROR;
    return (ATTESTATION_STATUS)0;
}

/* 函数描述: 这是发起者Enclave发送ECDH消息2到响应者Enclave，并接收来自响应者Enclave的ECDH消息3的OCALL接口
 * 参数描述:
 *      [输入] dh_msg2: 指向由发起者Enclave生成的ECDH消息2的指针
 *      [输入，输出] dh_msg3: 指向ECDH消息3的指针，这个缓冲区在发起者Enclave中分配，并由响应者Enclave填充
 *      [输入] session_id: 由响应者Enclave分配的会话ID
 * */
ATTESTATION_STATUS exchange_report_ocall(sgx_dh_msg2_t *dh_msg2, sgx_dh_msg3_t *dh_msg3, uint32_t session_id)
{
    sgx_status_t ret;
    uint32_t retcode;

    // 调用 exchange_report 函数，将消息2发送给响应者Enclave，并接收消息3
    ret = exchange_report(responder_enclave_id, &retcode, dh_msg2, dh_msg3, session_id);
    if (ret != SGX_SUCCESS || retcode != SGX_SUCCESS)
        return ATTESTATION_ERROR;
    return (ATTESTATION_STATUS)0;
}

/* 函数描述: 这是发起者Enclave发送加密请求消息到响应者Enclave，并接收来自响应者Enclave响应消息的OCALL接口
 * 参数描述:
 *      [输入] session_id: 由响应者Enclave分配的会话ID
 *      [输入] req_message: 指向请求消息的指针
 *      [输入] req_message_size: 请求消息的大小
 *      [输入] max_payload_size: 响应消息中的最大有效负载大小
 *      [输入，输出] resp_message: 指向响应消息的指针，该缓冲区由发起者Enclave分配并由响应者Enclave填充
 *      [输入] response message size: 响应消息的大小
 * */
ATTESTATION_STATUS send_request_ocall(uint32_t session_id, secure_message_t* req_message, size_t req_message_size, size_t max_payload_size, secure_message_t* resp_message, size_t resp_message_size)
{
    sgx_status_t ret;
    uint32_t retcode; 
    // 调用 generate_response 函数，向响应者Enclave发送请求并接收响应
    ret = generate_response(responder_enclave_id, &retcode, req_message, req_message_size, max_payload_size, resp_message, resp_message_size, session_id);
    if (ret != SGX_SUCCESS || retcode != SGX_SUCCESS)
        return INVALID_SESSION;

    return (ATTESTATION_STATUS)0;
}

/* 函数描述: 这是发起者Enclave关闭安全会话的OCALL接口
 * 参数描述:
 *      [输入] session_id: 由响应者Enclave分配的会话ID
 * */
ATTESTATION_STATUS end_session_ocall(uint32_t session_id)
{
    sgx_status_t ret;
    uint32_t retcode = (uint32_t) INVALID_SESSION;
    // 调用 end_session 函数，关闭会话
    ret = end_session(responder_enclave_id, &retcode, session_id);
    if (ret != SGX_SUCCESS || retcode != SGX_SUCCESS)
        return INVALID_SESSION;

    return (ATTESTATION_STATUS)0;
}

程序解释：
    这段代码实现了本地认证过程中发起者Enclave与响应者Enclave之间的一些OCALL接口。OCALL是指从受信任的环境调用未受信任环境中的功能。具体实现了以下4个OCALL接口：

• session_request_ocall:
  功能：从响应者Enclave获取ECDH协议的消息1和会话ID。
  实现：调用session_request函数，传递响应者Enclave的ID、返回代码、消息1缓冲区和会话ID指针。如果调用失败，返回认证错误代码。
• exchange_report_ocall:
  功能：向响应者Enclave发送ECDH协议的消息2，并接收来自响应者Enclave的消息3。
  实现：调用exchange_report函数，传递响应者Enclave的ID、返回代码、消息2、消息3和会话ID。如果调用失败，返回认证错误代码。
• send_request_ocall:
  功能：向响应者Enclave发送加密请求消息，并接收响应消息。
  实现：调用generate_response函数，传递响应者Enclave的ID、返回代码、请求消息及其大小、最大有效载荷大小、响应消息及其大小和会话ID。如果调用失败，返回无效会话错误代码。
• end_session_ocall:
  功能：关闭发起者Enclave与响应者Enclave之间的安全会话。
  实现：调用end_session函数，传递响应者Enclave的ID、返回代码和会话ID。如果调用失败，返回无效会话错误代码。

    这些OCALL接口将请求传递到响应者Enclave并返回结果，用于协调本地认证流程，确保两个Enclave之间的通信安全。

2.2.2 AppInitiator文件夹

    上面App是单线程实现两个enclave之间的互相认证，下面介绍的AppInitiator和AppResponder是通过两个线程分别实现请求者和响应者程序。

2.2.2.1 AppInitiator/App.cpp

#include <stdio.h>
#include <map>
#include <sched.h>
#include <sys/sysinfo.h>
#include <unistd.h> // POSIX标准API，如sleep、write等

#include "sgx_eid.h" // 用于SGX Enclave ID定义的头文件
#include "sgx_urts.h" // 用于SGX User Runtime库的头文件

#include "EnclaveInitiator_u.h" // 自动生成的未受信任部分的头文件，包含发起者Enclave的ECALL声明

#define ENCLAVE_INITIATOR_NAME "libenclave_initiator.signed.so"
// 定义发起者Enclave的已签名共享库文件名称

int main(int argc, char* argv[])
{
    int update = 0; // 更新标志
    uint32_t ret_status; // 返回状态
    sgx_status_t status; // SGX状态类型
    sgx_launch_token_t token = {0}; // 启动令牌，初始化为全零
    sgx_enclave_id_t initiator_enclave_id = 0; // 定义发起者Enclave的ID

    (void)argc;
    (void)argv;
    // 避免未使用参数的警告
    // 创建ECDH发起者Enclave
    status = sgx_create_enclave(ENCLAVE_INITIATOR_NAME, SGX_DEBUG_FLAG, &token, &update, &initiator_enclave_id, NULL);
    if (status != SGX_SUCCESS) {
        // 如果加载Enclave失败，打印错误信息并返回-1
        printf("failed to load enclave %s, error code is 0x%x.\n", ENCLAVE_INITIATOR_NAME, status);
        return -1;
    }
    printf("succeed to load enclave %s\n", ENCLAVE_INITIATOR_NAME);
    // 成功加载，打印成功信息

    // 使用发起者Enclave创建ECDH会话
    status = test_create_session(initiator_enclave_id, &ret_status);
    if (status != SGX_SUCCESS || ret_status != 0) {
        // 如果会话创建失败，打印错误信息、销毁Enclave并返回-1
        printf("failed to establish secure channel: ECALL return 0x%x, error code is 0x%x.\n", status, ret_status);
        sgx_destroy_enclave(initiator_enclave_id);
        return -1;
    }
    printf("succeed to establish secure channel.\n");
    // 成功建立会话，打印成功信息

    // 测试发起者Enclave和响应者Enclave之间的消息交换
    status = test_message_exchange(initiator_enclave_id, &ret_status);
    if (status != SGX_SUCCESS || ret_status != 0) {
        // 如果消息交换失败，打印错误信息、销毁Enclave并返回-1
        printf("test_message_exchange Ecall failed: ECALL return 0x%x, error code is 0x%x.\n", status, ret_status);
        sgx_destroy_enclave(initiator_enclave_id);
        return -1;
    }
    printf("Succeed to exchange secure message...\n");
    // 成功消息交换，打印成功信息

    // 关闭ECDH会话
    status = test_close_session(initiator_enclave_id, &ret_status);
    if (status != SGX_SUCCESS || ret_status != 0) {
        // 如果关闭会话失败，打印错误信息、销毁Enclave并返回-1
        printf("test_close_session Ecall failed: ECALL return 0x%x, error code is 0x%x.\n", status, ret_status);
        sgx_destroy_enclave(initiator_enclave_id);
        return -1;
    }
    printf("Succeed to close Session.\n");
    // 成功关闭会话，打印成功信息
    sgx_destroy_enclave(initiator_enclave_id);
    // 销毁发起者Enclave
    return 0;
    // 程序正常退出，返回0
}

总的来说，与上面单线程的App/App.cpp相差无几。

2.2.2.2 AppInitiator/UntrustedEnclaveMessageExchange.cpp

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h> // POSIX标准API，如sleep、write等
#include "sgx_eid.h" // 用于SGX Enclave ID定义的头文件
#include "error_codes.h" // 自定义错误码的头文件
#include "datatypes.h" // 自定义数据类型的头文件
#include "sgx_urts.h" // 用于SGX User Runtime库的头文件
#include "UntrustedEnclaveMessageExchange.h" // 非受信任部分的消息交换头文件
#include "sgx_dh.h" // 用于Diffie-Hellman密钥交换的SGX头文件

#include "fifo_def.h" // FIFO定义文件

#include <map> // 标准库map，用于字典结构

/* 函数描述：这是发起者Enclave获取响应者Enclave的ECDH消息1和会话ID的OCALL接口
 * 参数描述：
 *      [输入，输出] dh_msg1: 指向ECDH消息1缓冲区的指针，这个缓冲区在发起者Enclave中分配，并由响应者Enclave填充
 *      [输出] session_id: 指向由响应者Enclave分配的会话ID的指针
 * */
extern "C" ATTESTATION_STATUS session_request_ocall(sgx_dh_msg1_t* dh_msg1, uint32_t* session_id)
{
    FIFO_MSG msg1_request; // 定义消息1请求对象
    FIFO_MSG *msg1_response; // 指向消息1响应的指针
    SESSION_MSG1_RESP *msg1_respbody = NULL; // 指向消息1响应体的指针
    size_t msg1_resp_size; // 响应消息的大小

    msg1_request.header.type = FIFO_DH_REQ_MSG1; // 设置消息类型为DH密钥交换请求
    msg1_request.header.size = 0; // 设置消息大小为0

    // 发送并接收消息1请求
    if ((client_send_receive(&msg1_request, sizeof(FIFO_MSG), &msg1_response, &msg1_resp_size) != 0)
        || (msg1_response == NULL))
    {
        // 如果发送接收失败，打印错误信息并返回无效会话错误
        printf("fail to send and receive message.\n");
        return INVALID_SESSION;
    }

    // 将响应消息填充至dh_msg1和session_id
    msg1_respbody = (SESSION_MSG1_RESP *)msg1_response->msgbuf;
    memcpy(dh_msg1, &msg1_respbody->dh_msg1, sizeof(sgx_dh_msg1_t));
    *session_id = msg1_respbody->sessionid;
    free(msg1_response); // 释放响应消息

    return (ATTESTATION_STATUS)0;
}

/* 函数描述：这是发起者Enclave发送ECDH消息2到响应者Enclave，并接收来自响应者Enclave的ECDH消息3的OCALL接口
 * 参数描述：
 *      [输入] dh_msg2: 指向由发起者Enclave生成的ECDH消息2的指针
 *      [输入，输出] dh_msg3: 指向ECDH消息3的指针，这个缓冲区在发起者Enclave中分配，并由响应者Enclave填充
 *      [输入] session_id: 由响应者Enclave分配的会话ID
 * */
ATTESTATION_STATUS exchange_report_ocall(sgx_dh_msg2_t *dh_msg2, sgx_dh_msg3_t *dh_msg3, uint32_t session_id)
{
    FIFO_MSG *msg2 = NULL, *msg3 = NULL; // 定义消息2和消息3对象
    FIFO_MSG_HEADER *msg2_header = NULL; // 定义消息2头部指针
    SESSION_MSG2 *msg2_body = NULL; // 定义消息2体指针
    SESSION_MSG3 *msg3_body = NULL; // 定义消息3体指针
    size_t msg2size, msg3size; // 定义消息2和消息3大小

    msg2size = sizeof(FIFO_MSG_HEADER) + sizeof(SESSION_MSG2); // 设置消息2大小
    msg2 = (FIFO_MSG *)malloc(msg2size); // 为消息2分配内存
    if (!msg2)
    {
        // 如果内存分配失败，返回内存不足错误
        return ERROR_OUT_OF_MEMORY;
    }
    memset(msg2, 0, msg2size); // 清空消息2内存

    msg2_header = (FIFO_MSG_HEADER *)msg2; // 消息2头部指针
    msg2_header->type = FIFO_DH_MSG2; // 设置消息类型为DH消息2
    msg2_header->size = sizeof(SESSION_MSG2); // 设置消息大小

    msg2_body = (SESSION_MSG2 *)msg2->msgbuf; // 消息2体指针
    memcpy(&msg2_body->dh_msg2, dh_msg2, sizeof(sgx_dh_msg2_t)); // 复制消息2内容
    msg2_body->sessionid = session_id; // 设置会话ID

    // 发送并接收消息2
    if (client_send_receive(msg2, msg2size, &msg3, &msg3size) != 0)
    {
        free(msg2); // 释放消息2内存
        printf("failed to send and receive message.\n");
        return INVALID_SESSION;
    }

    // 将消息3内容复制到输出参数dh_msg3中
    msg3_body = (SESSION_MSG3 *)msg3->msgbuf;
    memcpy(dh_msg3, &msg3_body->dh_msg3, sizeof(sgx_dh_msg3_t));

    free(msg3); // 释放消息3内存
    free(msg2); // 再次释放消息2内存

    return (ATTESTATION_STATUS)0;
}

/* 函数描述：这是发起者Enclave发送加密请求消息到响应者Enclave，并接收来自响应者Enclave响应消息的OCALL接口
 * 参数描述：
 *      [输入] session_id: 由响应者Enclave分配的会话ID
 *      [输入] req_message: 指向请求消息的指针
 *      [输入] req_message_size: 请求消息的大小
 *      [输入] max_payload_size: 响应消息中的最大有效负载大小
 *      [输入，输出] resp_message: 指向响应消息的指针，该缓冲区由发起者Enclave分配并由响应者Enclave填充
 *      [输入] response message size: 响应消息的大小
 * */
ATTESTATION_STATUS send_request_ocall(uint32_t session_id, secure_message_t* req_message, size_t req_message_size, size_t max_payload_size, secure_message_t* resp_message, size_t resp_message_size)
{
    FIFO_MSG *msgreq = NULL, *msgresp = NULL; // 定义请求消息和响应消息对象
    FIFO_MSGBODY_REQ *msgbody; // 定义消息体指针

    size_t reqsize, respsize; // 定义请求和响应大小

    reqsize = sizeof(FIFO_MSG_HEADER) + sizeof(FIFO_MSGBODY_REQ) + req_message_size; // 设置请求大小

    msgreq = (FIFO_MSG *)malloc(reqsize); // 为请求消息分配内存
    if (!msgreq)
    {
        // 如果内存分配失败，返回内存不足错误
        return ERROR_OUT_OF_MEMORY;
    }
    memset(msgreq, 0, reqsize); // 清空请求消息内存

    msgreq->header.type = FIFO_DH_MSG_REQ; // 设置消息类型为DH请求消息
    msgreq->header.size = sizeof(FIFO_MSGBODY_REQ) + req_message_size; // 设置消息大小

    msgbody = (FIFO_MSGBODY_REQ *)msgreq->msgbuf; // 消息体指针
    msgbody->max_payload_size = max_payload_size; // 设置最大有效负载大小
    msgbody->size = req_message_size; // 设置请求消息大小
    msgbody->session_id = session_id; // 设置会话ID

    memcpy(msgbody->buf, req_message, req_message_size); // 复制请求消息内容

    // 发送并接收请求消息
    if (client_send_receive(msgreq, reqsize, &msgresp, &respsize) != 0)
    {
        free(msgreq); // 释放请求消息内存
        printf("fail to send and receive message.\n");
        return INVALID_SESSION;
    }

    // 将响应消息内容复制到输出参数resp_message中
    memcpy(resp_message, msgresp->msgbuf, msgresp->header.size < resp_message_size ? msgresp->header.size : resp_message_size);

    free(msgresp); // 释放响应消息内存
    free(msgreq); // 再次释放请求消息内存

    return (ATTESTATION_STATUS)0;
}

 /* 参数描述：
 *      [输入] session_id: 由响应者Enclave分配的会话ID
 * */
ATTESTATION_STATUS end_session_ocall(uint32_t session_id)
{
    FIFO_MSG *msgresp = NULL; // 定义指向响应消息的指针
    FIFO_MSG *closemsg; // 定义关闭消息对象
    SESSION_CLOSE_REQ *body; // 定义会话关闭请求体指针
    size_t reqsize, respsize; // 请求和响应的大小

    reqsize = sizeof(FIFO_MSG) + sizeof(SESSION_CLOSE_REQ); // 设置请求消息的大小
    closemsg = (FIFO_MSG *)malloc(reqsize); // 为关闭消息分配内存
    if (!closemsg)
    {
        // 如果内存分配失败，返回内存不足错误
        return ERROR_OUT_OF_MEMORY;
    }
    memset(closemsg, 0, reqsize); // 清空关闭消息内存

    closemsg->header.type = FIFO_DH_CLOSE_REQ; // 设置消息类型为会话关闭请求
    closemsg->header.size = sizeof(SESSION_CLOSE_REQ); // 设置消息体大小

    body = (SESSION_CLOSE_REQ *)closemsg->msgbuf; // 消息体指针
    body->session_id = session_id; // 设置会话ID

    // 发送关闭消息并接收响应
    if (client_send_receive(closemsg, reqsize, &msgresp, &respsize) != 0)
    {
        free(closemsg); // 释放关闭消息内存
        printf("fail to send and receive message.\n");
        return INVALID_SESSION;
    }

    free(closemsg); // 释放关闭消息内存
    free(msgresp); // 释放响应消息内存

    return (ATTESTATION_STATUS)0;
}

总的来说，与上面单线程的App/UntrustedEnclaveMessageExchange.cpp相差无几。

2.2.3 AppResponder文件夹

2.2.3.1 AppResponder/App.cpp

// App.cpp : Defines the entry point for the console application.
#include <stdio.h>
#include <map>
#include <sys/types.h>
#include <sys/stat.h>
#include <sched.h>
#include <sys/sysinfo.h>
#include <signal.h>

#include "EnclaveResponder_u.h" // 自动生成的未受信任部分头文件，包含响应者Enclave的ECALL声明
#include "sgx_eid.h" // 用于SGX Enclave ID定义的头文件
#include "sgx_urts.h" // 用于SGX User Runtime库的头文件

#include "fifo_def.h" // FIFO定义文件
#include "datatypes.h" // 自定义数据类型头文件

#include "CPTask.h" // 任务处理类的头文件
#include "CPServer.h" // 服务器类的头文件

#define __STDC_FORMAT_MACROS
#include <inttypes.h> // 提供大整数格式化的头文件

#define UNUSED(val) (void)(val) // 定义未使用参数的宏
#define TCHAR   char
#define _TCHAR  char
#define _T(str) str
#define scanf_s scanf
#define _tmain  main

CPTask * g_cptask = NULL; // 全局变量，任务处理类指针
CPServer * g_cpserver = NULL; // 全局变量，服务器类指针

// 信号处理函数
void signal_handler(int sig)
{
    switch(sig)
    {
        case SIGINT: // 处理SIGINT信号
        case SIGTERM: // 处理SIGTERM信号
        {
            if (g_cpserver)
                g_cpserver->shutDown(); // 如果服务器存在，调用其关闭函数
        }
        break;
    default:
        break;
    }
    exit(1); // 退出程序
}

// 清理函数，销毁全局对象
void cleanup()
{
    if(g_cptask != NULL)
        delete g_cptask;
    if(g_cpserver != NULL)
        delete g_cpserver;
}

// 主函数
int  main(int argc, char* argv[])
{
    (void)argc;
    (void)argv; // 忽略未使用的参数

    // 创建服务器实例，它将在套接字上监听并处理客户端请求
    g_cptask = new (std::nothrow) CPTask;
    g_cpserver = new (std::nothrow) CPServer(g_cptask);

    if (!g_cptask || !g_cpserver)
         return -1; // 如果创建失败，返回-1

    atexit(cleanup); // 注册退出时的清理函数

    // 注册信号处理器函数，以响应用户中断
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);

    g_cptask->start(); // 启动任务处理

    if (g_cpserver->init() != 0)
    {
         printf("fail to init server\n"); // 初始化服务器失败，打印错误信息
    }
    else
    {
         printf("Server is ON...\n");
         printf("Press Ctrl+C to exit...\n");
         g_cpserver->doWork(); // 服务器初始化成功，启动服务器工作
    }

    return 0; // 程序正常结束
}

程序解释：
    这段代码主要用于设置和启动一个SGX应用程序中的服务器实例。它包括以下几个主要步骤：

• 创建和初始化CPTask任务处理器和CPServer服务器实例。
• 注册信号处理器和退出时的清理函数，以确保资源在程序终止时被正确释放。
• 启动任务处理器和服务器，处理客户端请求和本地认证流程。

2.2.3.2 AppResponder/CPServer.cpp

#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/un.h>

#include "CPServer.h"

#define BACKLOG 5 // 最大连接等待队列长度
#define CONCURRENT_MAX 32 // 最大并发连接数
#define SERVER_PORT 8888 // 服务器端口号（Windows）
#define BUFFER_SIZE 1024 // 缓冲区大小

#define UNIX_DOMAIN "/tmp/UNIX.domain" // Unix Domain Socket 文件路径

/* 函数描述：
 * 这是服务器初始化例程，它创建TCP套接字并监听一个端口。
 * 在Linux上，它会监听名为 '/tmp/UNIX.domain' 的域套接字
 * 在Windows上，它会监听8888端口，仅用于示范目的
 * */
int CPServer::init()
{
    struct sockaddr_un srv_addr;
    // 创建UNIX域套接字
    m_server_sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (m_server_sock_fd == -1)
    {
        printf("socket initiazation error\n");
        return -1; // 套接字初始化失败，返回-1
    }

    srv_addr.sun_family = AF_UNIX;
    strncpy(srv_addr.sun_path, UNIX_DOMAIN, sizeof(srv_addr.sun_path) - 1); // 设置域套接字路径
    unlink(UNIX_DOMAIN); // 删除已存在的文件

    // 绑定套接字
    int bind_result = bind(m_server_sock_fd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));
    if (bind_result == -1)
    {
        printf("bind error\n");
        close(m_server_sock_fd); // 绑定失败，关闭套接字并返回-1
        return -1;
    }
    // 监听套接字
    if (listen(m_server_sock_fd, BACKLOG) == -1)
    {
        printf("listen error\n");
        close(m_server_sock_fd); // 监听失败，关闭套接字并返回-1
        return -1;
    }
    m_shutdown = 0; // 初始化停止标志
    return 0; // 成功返回0
}

/* 函数描述：
 * 这是服务器的主要例程，它使用select()来接受新连接并接收来自客户端的消息。
 * 当它接收到客户端的请求消息后，它会将消息放入任务队列并唤醒工作线程处理请求。
 * */
void CPServer::doWork()
{
    int client_fds[CONCURRENT_MAX] = {0}; // 客户端连接描述符数组，初始化为0
    fd_set server_fd_set; // 文件描述符集合
    int max_fd = -1; // 最大文件描述符
    struct timeval tv; // 超时时间
    char input_msg[BUFFER_SIZE]; // 输入消息缓冲区
    char recv_msg[BUFFER_SIZE]; // 接收消息缓冲区

    while (!m_shutdown)
    {
        // 为select()设置20秒超时
        tv.tv_sec = 20;
        tv.tv_usec = 0;
        FD_ZERO(&server_fd_set); // 清空文件描述符集合
        FD_SET(STDIN_FILENO, &server_fd_set); // 将标准输入加入集合
        if (max_fd < STDIN_FILENO)
            max_fd = STDIN_FILENO; // 更新最大文件描述符
        // 监听服务器套接字
        FD_SET(m_server_sock_fd, &server_fd_set);
        if (max_fd < m_server_sock_fd)
            max_fd = m_server_sock_fd; // 更新最大文件描述符
        // 监听所有客户端连接
        for (int i = 0; i < CONCURRENT_MAX; i++) {
            if (client_fds[i] != 0) {
                FD_SET(client_fds[i], &server_fd_set);
                if (max_fd < client_fds[i])
                    max_fd = client_fds[i]; // 更新最大文件描述符
            }
        }
        // 调用select()等待事件
        int ret = select(max_fd + 1, &server_fd_set, NULL, NULL, &tv);
        if (ret < 0) {
            printf("Warning: server would shutdown\n");
            continue; // select()失败，继续循环
        } else if (ret == 0) {
            // 超时，继续循环
            continue;
        }
        if (FD_ISSET(m_server_sock_fd, &server_fd_set)) {
            // 如果有新的连接请求
            struct sockaddr_un clt_addr;
            socklen_t len = sizeof(clt_addr);
            // 接受连接请求
            int client_sock_fd = accept(m_server_sock_fd, (struct sockaddr *)&clt_addr, &len);
            if (client_sock_fd > 0) {
                // 如果连接池未满，将新连接加入连接池
                int index = -1;
                for (int i = 0; i < CONCURRENT_MAX; i++) {
                    if (client_fds[i] == 0) {
                        index = i;
                        client_fds[i] = client_sock_fd;
                        break;
                    }
                }
                if (index < 0) {
                    printf("server reach maximum connection!\n");
                    bzero(input_msg, BUFFER_SIZE);
                    strcpy(input_msg, "server reach maximum connection\n");
                    send(client_sock_fd, input_msg, BUFFER_SIZE, 0);
                } else if (client_sock_fd < 0) {
                    printf("server: accept() return failure, %s, would exit.\n", strerror(errno));
                    close(m_server_sock_fd);
                    break;
                }
            }
        }
        for (int i = 0; i < CONCURRENT_MAX; i++) {
            if ((client_fds[i] != 0)
                && (FD_ISSET(client_fds[i], &server_fd_set))) {
                // 如果有来自客户端的请求消息
                FIFO_MSG *msg;
                bzero(recv_msg, BUFFER_SIZE);
                long byte_num = recv(client_fds[i], recv_msg, BUFFER_SIZE, 0);
                if (byte_num > 0) {
                    if (byte_num > BUFFER_SIZE)
                        byte_num = BUFFER_SIZE;
                    recv_msg[byte_num] = '\0';

                    msg = (FIFO_MSG *)malloc(byte_num);
                    if (!msg) {
                        printf("memory allocation failure\n");
                        continue;
                    }
                    memset(msg, 0, byte_num);
                    memcpy(msg, recv_msg, byte_num);
                    msg->header.sockfd = client_fds[i];
                    // 将请求消息放入事件队列
                    m_cptask->puttask(msg);
                } else if (byte_num < 0) {
                    printf("failed to receive message.\n");
                } else {
                    // 客户端连接关闭
                    FD_CLR(client_fds[i], &server_fd_set);
                    close(client_fds[i]);
                    client_fds[i] = 0;
                }
            }
        }
    }
}

/* 函数描述：
 * 这是关闭服务器的函数。当进程退出时调用。
 * */
void CPServer::shutDown()
{
    printf("Server would shutdown...\n");
    m_shutdown = 1; // 设置停止标志
    m_cptask->shutdown(); // 停止任务处理
    close(m_server_sock_fd); // 关闭服务器套接字
}

功能分析

• 初始化服务器（init方法）：
  功能：创建UNIX域套接字绑定到路径/tmp/UNIX.domain并开始监听连接请求。
  实现：创建套接字 socket(AF_UNIX, SOCK_STREAM, 0)。
  设置套接字地址结构 srv_addr 的家庭类型为 AF_UNIX，并指定路径 UNIX_DOMAIN。调用bind函数绑定套接字到地址。通过listen函数使套接字开始监听连接请求。如果过程中任何一步失败，关闭套接字并返回-1，否则返回0表示成功。
• 处理客户端连接和消息（doWork方法）：
  功能：使用select函数接受新的连接和处理来自客户端的消息。
  实现：使用select函数监视多个文件描述符，检测新的连接请求和来自客户端的消息。如果select检测到新连接请求，调用accept函数接受连接并将新客户端加入client_fds数组中。如果select检测到客户端的请求消息，调用recv函数接收消息并将其复制到FIFO_MSG结构中，之后将消息放入任务队列中供处理。如果客户端连接关闭或发生错误，关闭相应的客户端套接字并从client_fds数组中移除。
• 关闭服务器（shutDown方法）：
  功能：当服务器需要关闭时调用的函数，控制服务器的关机流程。
  实现：打印关闭服务器的消息。设置停止标志 m_shutdown 为 1。

2.2.3.3 AppResponder/CPTask.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <map>
#include <sys/stat.h>
#include <sched.h>

#include "EnclaveResponder_u.h" // 自动生成的未受信任部分头文件，包含响应者Enclave的ECALL声明
#include "sgx_eid.h" // 用于SGX Enclave ID定义的头文件
#include "sgx_urts.h" // 用于SGX User Runtime库的头文件

#include "cpdef.h" // 自定义的协议定义头文件
#include "fifo_def.h" // FIFO定义文件
#include "datatypes.h" // 自定义数据类型头文件

#include "CPTask.h" // 任务处理类的头文件
#include "CPServer.h" // 服务器类的头文件

sgx_enclave_id_t e2_enclave_id = 0; // 定义响应者Enclave ID

#define ENCLAVE_RESPONDER_NAME "libenclave_responder.signed.so" // 定义响应者Enclave的已签名共享库文件名称

/* 函数描述：加载响应者Enclave
 * */
int load_enclaves()
{
    sgx_status_t ret = SGX_SUCCESS; // SGX状态类型
    sgx_launch_token_t token = {0}; // 启动令牌，初始化为全零
    int update = 0; // 更新标志
    ret = sgx_create_enclave(ENCLAVE_RESPONDER_NAME, SGX_DEBUG_FLAG, &token, &update, &e2_enclave_id, NULL);
    if (ret != SGX_SUCCESS) 
    {
        // 如果加载Enclave失败，打印错误信息并返回-1
        printf("failed to load enclave %s, error code is 0x%x.\n", ENCLAVE_RESPONDER_NAME, ret);
        return -1;
    }
    return 0; // 加载成功返回0
}

/* 函数描述：
 * 该函数响应发起者Enclave的连接请求，通过生成并返回ECDH消息1
 * 参数描述：
 *  [输入] clientfd: 客户端的连接ID。在生成ECDH消息1后，服务器将通过此连接ID发送响应。
 * */
int generate_and_send_session_msg1_resp(int clientfd)
{
    int retcode = 0; // 初始化返回码
    uint32_t status = 0; // SGX状态码
    sgx_status_t ret = SGX_SUCCESS; // SGX状态类型
    SESSION_MSG1_RESP msg1resp; // 会话消息1响应结构体
    FIFO_MSG *fifo_resp = NULL; // 指向FIFO响应消息的指针
    size_t respmsgsize; // 响应消息大小
    memset(&msg1resp, 0, sizeof(SESSION_MSG1_RESP)); // 清空消息1响应结构体
    // 调用响应者Enclave生成ECDH消息1
    ret = session_request(e2_enclave_id, &status, &msg1resp.dh_msg1, &msg1resp.sessionid);
    if (ret != SGX_SUCCESS)
    {
        printf("failed to do ECALL session_request.\n");
        return -1; // 如果生成失败，打印错误信息并返回-1
    }
    respmsgsize = sizeof(FIFO_MSG) + sizeof(SESSION_MSG1_RESP); // 计算响应消息大小
    fifo_resp = (FIFO_MSG *)malloc(respmsgsize); // 分配内存
    if (!fifo_resp)
    {
        printf("memory allocation failure.\n");
        return -1; // 如果内存分配失败，打印错误信息并返回-1
    }
    memset(fifo_resp, 0, respmsgsize); // 清空分配的内存
    fifo_resp->header.type = FIFO_DH_RESP_MSG1; // 设置消息类型
    fifo_resp->header.size = sizeof(SESSION_MSG1_RESP); // 设置消息大小
    memcpy(fifo_resp->msgbuf, &msg1resp, sizeof(SESSION_MSG1_RESP)); // 复制响应内容到FIFO消息中
    // 发送消息1到客户端
    if (send(clientfd, reinterpret_cast<char *>(fifo_resp), static_cast<int>(respmsgsize), 0) == -1)
    {
        printf("fail to send msg1 response.\n");
        retcode = -1; // 如果发送失败，打印错误信息，并设置返回码为-1
    }
    free(fifo_resp); // 释放内存
    return retcode; // 返回结果码
}

/* 函数描述：
 * 该函数处理从客户端接收的ECDH消息2，并向客户端发送消息3
 * 参数描述：
 *  [输入] clientfd: 客户端的连接ID
 *  [输入] msg2: 包含从客户端接收的ECDH消息2
 * */
int process_exchange_report(int clientfd, SESSION_MSG2 *msg2)
{
    uint32_t status = 0; // SGX状态码
    sgx_status_t ret = SGX_SUCCESS; // SGX状态类型
    FIFO_MSG *response; // 指向FIFO响应消息的指针
    SESSION_MSG3 *msg3; // 指向ECDH消息3的指针
    size_t msgsize; // 消息大小
    if (!msg2)
        return -1; // 检查消息2是否为空，如果为空返回-1
    
    msgsize = sizeof(FIFO_MSG_HEADER) + sizeof(SESSION_MSG3); // 计算消息大小
    response = (FIFO_MSG *)malloc(msgsize); // 分配内存
    if (!response)
    {
        printf("memory allocation failure\n");
        return -1; // 如果内存分配失败，打印错误信息并返回-1
    }
    memset(response, 0, msgsize); // 清空分配的内存
    
    response->header.type = FIFO_DH_MSG3; // 设置消息类型
    response->header.size = sizeof(SESSION_MSG3); // 设置消息大小
    
    msg3 = (SESSION_MSG3 *)response->msgbuf; // 消息体指针
    msg3->sessionid = msg2->sessionid; // 设置会话ID

    // 调用响应者Enclave处理ECDH消息2并生成消息3
    ret = exchange_report(e2_enclave_id, &status, &msg2->dh_msg2, &msg3->dh_msg3, msg2->sessionid);
    if (ret != SGX_SUCCESS)
    {
        printf("EnclaveResponse_exchange_report failure.\n");
        free(response); // 如果失败，打印错误信息并释放内存
        return -1;
    }
    // 发送消息3到客户端
    if (send(clientfd, reinterpret_cast<char *>(response), static_cast<int>(msgsize), 0) == -1)
    {
        printf("server_send() failure.\n");
        free(response); // 如果发送失败，打印错误信息并释放内存
        return -1;
    }
    free(response); // 释放内存
    return 0; // 返回0表示成功
}

/* 函数描述：
 * 该函数处理从客户端接收的消息通信
 * 参数描述：
 *  [输入] clientfd: 客户端的连接ID
 *  [输入] req_msg: 指向从客户端接收的请求消息的指针
 * */
int process_msg_transfer(int clientfd, FIFO_MSGBODY_REQ *req_msg)
{
    uint32_t status = 0; // SGX状态码
    sgx_status_t ret = SGX_SUCCESS; // SGX状态类型
    secure_message_t *resp_message = NULL; // 指向响应消息的指针
    FIFO_MSG *fifo_resp = NULL; // 指向FIFO响应消息的指针
    size_t resp_message_size; // 响应消息大小

    if (!req_msg)
    {
        printf("invalid parameter.\n");
        return -1; // 检查请求消息是否为空，如果为空返回-1
    }
    resp_message_size = sizeof(secure_message_t) + req_msg->max_payload_size; // 计算响应消息大小
    // 分配内存给响应消息
    resp_message = (secure_message_t*)malloc(resp_message_size);
    if (!resp_message)
    {
        printf("memory allocation failure.\n");
        return -1; // 如果内存分配失败，打印错误信息并返回-1
    }
    memset(resp_message, 0, resp_message_size); // 清空分配的内存
    // 调用响应者Enclave生成响应消息
    ret = generate_response(e2_enclave_id, &status, (secure_message_t *)req_msg->buf, req_msg->size, req_msg->max_payload_size, resp_message, resp_message_size, req_msg->session_id);
    if (ret != SGX_SUCCESS)
    {
        printf("EnclaveResponder_generate_response error.\n");
        free(resp_message); // 如果失败，打印错误信息并释放内存
        return -1;
    }
    fifo_resp = (FIFO_MSG *)malloc(sizeof(FIFO_MSG) + resp_message_size); // 分配内存给FIFO响应消息
    if (!fifo_resp)
    {
        printf("memory allocation failure.\n");
                free(resp_message); // 释放响应消息内存
        return -1; // 返回内存分配失败错误
    }
    memset(fifo_resp, 0, sizeof(FIFO_MSG) + resp_message_size); // 清空分配的FIFO响应消息内存

    fifo_resp->header.type = FIFO_DH_MSG_RESP; // 设置消息类型为响应消息
    fifo_resp->header.size = resp_message_size; // 设置消息大小
    memcpy(fifo_resp->msgbuf, resp_message, resp_message_size); // 复制响应消息内容到FIFO消息缓冲区
    free(resp_message); // 释放响应消息内存
    // 发送响应消息到客户端
    if (send(clientfd, reinterpret_cast<char *>(fifo_resp), sizeof(FIFO_MSG) + static_cast<int>(resp_message_size), 0) == -1)
    {
        printf("server_send() failure.\n");
        free(fifo_resp); // 如果发送失败，打印错误信息并释放FIFO消息内存
        return -1; // 返回发送失败错误
    }
    free(fifo_resp); // 释放FIFO消息内存
    return 0; // 返回0表示成功
}

/* 函数描述：处理来自客户端的会话关闭请求
 * 参数描述：
 *  [输入] clientfd: 客户端的连接ID
 *  [输入] close_req: 指向客户端的会话关闭请求的指针
 * */
int process_close_req(int clientfd, SESSION_CLOSE_REQ *close_req)
{
    uint32_t status = 0; // SGX状态码
    sgx_status_t ret = SGX_SUCCESS; // SGX状态类型
    FIFO_MSG close_ack; // 定义关闭确认消息

    if (!close_req)
        return -1; // 检查关闭请求是否为空，如果为空返回-1

    // 调用响应者Enclave关闭会话
    ret = end_session(e2_enclave_id, &status, close_req->session_id);
    if (ret != SGX_SUCCESS)
        return -1; // 如果失败，返回会话关闭错误

    // 发送会话关闭确认响应
    memset(&close_ack, 0, sizeof(FIFO_MSG)); // 清空关闭确认消息内存
    close_ack.header.type = FIFO_DH_CLOSE_RESP; // 设置消息类型为关闭响应
    close_ack.header.size = 0; // 设置消息大小为0

    if (send(clientfd, reinterpret_cast<char *>(&close_ack), sizeof(FIFO_MSG), 0) == -1)
    {
        printf("server_send() failure.\n");
        return -1; // 如果发送失败，打印错误信息并返回发送失败错误
    }

    return 0; // 返回0表示成功
}

void CPTask::run()
{
    FIFO_MSG *message = NULL; // 定义指向消息的指针
    sgx_launch_token_t token = {0}; // 启动令牌，初始化为全零
    sgx_status_t status; // SGX状态类型
    int update = 0; // 更新标志
    // 加载响应者Enclave 
    status = sgx_create_enclave(ENCLAVE_RESPONDER_NAME, SGX_DEBUG_FLAG, &token, &update, &e2_enclave_id, NULL);
    if (status != SGX_SUCCESS)
    {
        printf("failed to load enclave %s, error code is 0x%x.\n", ENCLAVE_RESPONDER_NAME, status);
        return; // 如果加载失败，打印错误信息并返回
    }
    while (!isStopped())
    {
        /* 从队列中接收任务 */
        message = m_queue.blockingPop();
        if (isStopped())
        {
            free(message); // 如果已停止，释放消息内存并跳出循环
            break;
        }
        switch (message->header.type)
        {
            case FIFO_DH_REQ_MSG1:
            {
                // 处理ECDH会话连接请求
                int clientfd = message->header.sockfd;
                if (generate_and_send_session_msg1_resp(clientfd) != 0)
                {
                    printf("failed to generate and send session msg1 resp.\n");
                    break; // 如果生成并发送会话消息1失败，打印错误信息并跳出循环
                }
            }
            break;

            case FIFO_DH_MSG2:
            {
                // 处理ECDH消息2
                int clientfd = message->header.sockfd;
                SESSION_MSG2 *msg2 = NULL;
                msg2 = (SESSION_MSG2 *)message->msgbuf;

                if (process_exchange_report(clientfd, msg2) != 0)
                {
                    printf("failed to process exchange_report request.\n");
                    break; // 如果处理消息交换报告失败，打印错误信息并跳出循环
                }
            }
            break;

            case FIFO_DH_MSG_REQ:
            {
                // 处理消息传输请求
                int clientfd = message->header.sockfd;
                FIFO_MSGBODY_REQ *msg = NULL;

                msg = (FIFO_MSGBODY_REQ *)message->msgbuf;

                if (process_msg_transfer(clientfd, msg) != 0)
                {
                    printf("failed to process message transfer request.\n");
                    break; // 如果处理消息传输请求失败，打印错误信息并跳出循环
                }
            }
            break;

            case FIFO_DH_CLOSE_REQ:
            {
                // 处理关闭会话请求
                int clientfd = message->header.sockfd;
                SESSION_CLOSE_REQ *closereq = NULL;

                closereq = (SESSION_CLOSE_REQ *)message->msgbuf;

                process_close_req(clientfd, closereq); // 处理关闭会话请求
            }
            break;

            default:
            {
                printf("Unknown message.\n"); // 未知消息类型，打印错误信息
            }
            break;
        }
        free(message); // 释放消息内存
        message = NULL;
    }
    sgx_destroy_enclave(e2_enclave_id); // 销毁响应者Enclave
}

void CPTask::shutdown()
{
    stop(); // 停止任务
    m_queue.close(); // 关闭消息队列
    join(); // 等待任务结束
}

void CPTask::puttask(FIFO_MSG* requestData)
{
    if (isStopped()) {
        return; // 如果已停止，不处理任务
    }
    m_queue.push(requestData); // 将任务放入消息队列
}

   这段代码实现了一个负责处理从客户端接收的任务类CPTask，并通过与SGX Enclave进行交互完成任务。主要功能包括以下几个部分：
函数 process_close_req：
功能：处理来自客户端的会话关闭请求。
实现：检查关闭请求参数是否为空，如果为空则返回-1。调用 end_session 函数通过Enclave关闭会话。发送会话关闭确认响应到客户端。成功关闭会话返回0，否则返回-1。
方法 CPTask::run：
功能：任务处理的主逻辑，加载Enclave并处理消息队列中的任务。
实现：加载响应者Enclave。在循环中不断从消息队列中取出任务，根据任务类型分别处理不同的任务。包括会话请求、消息交换、消息传输和会话关闭等任务。如果遇到未知的消息类型，打印错误信息。结束后销毁Enclave。
方法 CPTask::shutdown：
功能：停止任务处理，关闭消息队列并等待任务结束。
实现：调用 stop 方法停止任务。关闭消息队列。等待任务结束。
方法 CPTask::puttask：
功能：将任务放入消息队列。
实现：检查任务是否已停止，如果已停止则不处理任务。
将任务放入消息队列。

   综上所述，这段代码通过注册信号处理器和任务队列的使用，确保了从客户端接收任务并对其进行处理的完整流程。主要实现了本地认证过程中的消息交换和会话管理，并与SGX Enclave进行交互，确保数据和通信的安全性。

2.2.4 EnclaveInitiator文件夹

• EnclaveInitiator.cpp

// Enclave1.cpp : Defines the exported functions for the .so application
#include "sgx_eid.h" // 用于SGX Enclave ID定义的头文件
#include "EnclaveInitiator_t.h" // 自动生成的可信部分头文件，包含发起者Enclave的ECALL声明
#include "EnclaveMessageExchange.h" // 消息交换相关头文件
#include "error_codes.h" // 自定义错误码头文件
#include "Utility_E1.h" // 实用函数头文件
#include "sgx_dh.h" // 用于Diffie-Hellman密钥交换的SGX头文件
#include "sgx_utils.h" // 用于SGX实用函数的头文件
#include <map> // 标准库map，用于字典结构

#define UNUSED(val) (void)(val) // 忽略未使用参数的宏定义
#define RESPONDER_PRODID 1 // 响应者Enclave的产品ID

std::map<sgx_enclave_id_t, dh_session_t> g_src_session_info_map; // 定义全局映射，存储源会话信息

dh_session_t g_session; // 定义一个全局会话变量

// 这是响应者Enclave的MRSIGNER，需要与响应者Enclave的签名密钥一致
// 请在您的项目中替换为您的响应者Enclave的真实MRSIGNER！！！（参考上面MRSIGNER的生成方法，这里已经替换）
// 获取签名的Enclave的MRSIGNER的命令：<SGX_SDK安装路径>/bin/x64/sgx_sign dump -enclave <已签名的Enclave，.signer.so文件> -dumpfile mrsigner.txt
// 在mrsigner.txt中找到签名的Enclave的MRSIGNER(mrsigner->value:)，然后替换下面的值
sgx_measurement_t g_responder_mrsigner = {
    {
        0x68, 0xfb, 0x5b, 0x3c, 0x69, 0x38, 0x34, 0x4f, 0x7b, 0x0e, 0x3d, 0x68, 0x2a, 0x46, 0x36, 0x70, 
        0xca, 0xc5, 0x2b, 0xf2, 0xfd, 0xf6, 0xc8, 0x90, 0x48, 0xc3, 0x6d, 0xcb, 0x85, 0x3f, 0xc8, 0x59 
    }
};
/* 函数描述：
 * 这是创建ECDH会话的ECALL例程。
 * 当成功创建ECDH会话时，会话上下文保存到g_session中。
 * */
extern "C" uint32_t test_create_session()
{
    return create_session(&g_session); // 调用create_session函数创建会话
}

/* 函数描述：
 * 这是与ECDH对等方传输消息的ECALL例程。
 * */
uint32_t test_message_exchange()
{
    ATTESTATION_STATUS ke_status = SUCCESS; // 定义验证状态
    uint32_t target_fn_id, msg_type; // 目标函数ID和消息类型
    char* marshalled_inp_buff; // 序列化输入缓冲区指针
    size_t marshalled_inp_buff_len; // 序列化输入缓冲区长度
    char* out_buff; // 输出缓冲区指针
    size_t out_buff_len; // 输出缓冲区长度
    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;   // 假设响应消息中的最大有效负载大小为50字节，出于演示目的
    secret_data = 0x12345678; // 秘密数据在此仅用于演示目的

    // 将秘密数据序列化到缓冲区中
    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;
    }
    // 核心参考代码函数
    ke_status = send_request_receive_response(&g_session, 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;
    }
    // 反序列化秘密响应数据
    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;
}

/* 函数描述：
 * 这是关闭安全会话的ECALL接口*/
extern "C" uint32_t test_close_session()
{
    ATTESTATION_STATUS ke_status = SUCCESS; // 定义验证状态
    ke_status = close_session(&g_session); // 调用close_session函数关闭会话
    // 擦除会话上下文
    memset(&g_session, 0, sizeof(dh_session_t));
    return ke_status;
}

/* 函数描述：
 * 验证对等Enclave的身份。
 * 出于演示目的，验证以下几点：
 *   1. 对等Enclave的MRSIGNER符合预期
 *   2. 对等Enclave的产品ID(Prod ID)符合预期
 *   3. 对等Enclave的属性合理：它是已初始化的Enclave；在非调试配置中，Enclave未以调试模式加载。
 * */
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;

    // 检查对等Enclave的MRSIGNER，请在您的项目中启用此检查！！！这步很关键！！！
    // 注意：一定是上面的g_responder_mrsigner替换为真实的签名值后才能验证通过！！！
    if (memcmp((uint8_t *)&peer_enclave_identity->mr_signer, (uint8_t*)&g_responder_mrsigner, sizeof(sgx_measurement_t)))
        return ENCLAVE_TRUST_ERROR;
        
    // 检查对等Enclave的产品ID和Enclave属性（应已初始化）
    if (peer_enclave_identity->isv_prod_id != RESPONDER_PRODID || !(peer_enclave_identity->attributes.flags & SGX_FLAGS_INITTED))
        return ENCLAVE_TRUST_ERROR;

    // 检查Enclave未以调试模式加载，除非项目是为调试目的构建的
#if defined(NDEBUG)
    if (peer_enclave_identity->attributes.flags & SGX_FLAGS_DEBUG)
        return ENCLAVE_TRUST_ERROR;
#endif

    return SUCCESS;
}

/* 函数描述：操作输入秘密并生成输出秘密
 * */
uint32_t get_message_exchange_response(uint32_t inp_secret_data)
{
    uint32_t secret_response;
    // 用户应使用更复杂的加密方法来保护他们的秘密，下面的例子只是一个简单的示例
    secret_response = inp_secret_data & 0x11111111;
    return secret_response;
}

// 从请求消息生成响应
/* 函数描述：
 * 处理请求消息并生成响应
 * 参数描述：
 *   [输入] decrypted_data: 指向解密消息的指针
 *   [输出] resp_buffer: 指向响应消息的指针，缓冲区在本函数内分配
 *   [输出] resp_length: 指向响应长度的指针
 * */
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;
}

功能分析:
创建会话 test_create_session：
功能：调用 create_session 函数创建一个ECDH会话，并将会话上下文保存到全局变量 g_session 中。
实现：直接调用 create_session 函数并返回其结果。
消息交换 test_message_exchange：
功能：与ECDH对等方传输消息，包括序列化发送和反序列化接收。

• EnclaveInitiator.edl

enclave {
    include "sgx_eid.h"
    include "datatypes.h"
    include "dh_session_protocol.h"
    
    trusted{
            public uint32_t test_create_session();
            public uint32_t test_message_exchange();
            public uint32_t test_close_session();
    };

    untrusted{
	    uint32_t session_request_ocall([out] sgx_dh_msg1_t *dh_msg1,[out] uint32_t *session_id);
            uint32_t exchange_report_ocall([in] sgx_dh_msg2_t *dh_msg2, [out] sgx_dh_msg3_t *dh_msg3, uint32_t session_id);
            uint32_t send_request_ocall(uint32_t session_id, [in, size = req_message_size] secure_message_t* req_message, size_t req_message_size, size_t max_payload_size, [out, size=resp_message_size] secure_message_t* resp_message, size_t resp_message_size);
            uint32_t end_session_ocall(uint32_t session_id);
    };
};

   注意，这里只有一点需要解释，在Initiator enclave中定义的edl文件主要包含trusted和untrusted两部分，untrusted部分是该enclave主动发起调用的OCALL接口，这主要因为Initiator enclave作为认证的发起方需要主动向外界发起调用，而下面的Responder Enclave的edl文件中就只有trusted部分而没有untrusted，因为Responder Enclave只要被动响应而不需要主要对外界发起。捋清楚这一点有助于帮我们分析整个程序流程！

2.2.5 EnclaveResponder文件夹

// Enclave2.cpp : Defines the exported functions for the DLL application
#include "sgx_eid.h" // 用于SGX Enclave ID定义的头文件
#include "EnclaveResponder_t.h" // 自动生成的可信部分头文件，包含响应者Enclave的ECALL声明
#include "EnclaveMessageExchange.h" // 消息交换相关头文件
#include "error_codes.h" // 自定义错误码头文件
#include "Utility_E2.h" // 实用函数头文件
#include "sgx_dh.h" // 用于Diffie-Hellman密钥交换的SGX头文件
#include "sgx_utils.h" // 用于SGX实用函数的头文件
#include <map> // 标准库map，用于字典结构

#define UNUSED(val) (void)(val) // 忽略未使用参数的宏定义

std::map<sgx_enclave_id_t, dh_session_t> g_src_session_info_map; // 定义全局映射，存储源会话信息

// 这是预期的发起者的MRSIGNER，请在您的项目中替换为您的响应者Enclave的MRSIGNER！！！（这里已替换为我的真实值）
// 获取签名的Enclave的MRSIGNER的命令：<SGX_SDK安装路径>/bin/x64/sgx_sign dump -enclave <已签名的Enclave> -dumpfile mrsigner.txt
// 在mrsigner.txt中找到签名的Enclave的MRSIGNER(mrsigner->value:)，然后替换下面的值
sgx_measurement_t g_initiator_mrsigner = {
    {
        0x39, 0xc7, 0xa4, 0xae, 0xa9, 0x64, 0xb9, 0x8e, 0xda, 0xa7, 0x22, 0x69, 0x98, 0x85, 0x0f, 0x92, 
        0x4d, 0xc3, 0x30, 0xa0, 0xac, 0xfe, 0x8f, 0xe0, 0xe2, 0x0a, 0xef, 0x9a, 0xd4, 0xde, 0xa9, 0x48    
    }
};

/* 函数描述：
 * 验证对等Enclave的身份
 * 出于演示目的，验证以下几点：
 *   1. 对等Enclave的MRSIGNER符合预期
 *   2. 对等Enclave的产品ID(Prod ID)符合预期
 *   3. 对等Enclave的属性合理，应为已初始化且未设置DEBUG属性（除非项目是以DEBUG选项构建的）
 * */
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; // 检查输入参数是否为空

    // 检查对等Enclave的MRSIGNER，请在您的项目中启用此检查！！！这步很关键！！！
    // 注意：一定是上面的g_responder_mrsigner替换为真实的签名值后才能验证通过！！！
    if (memcmp((uint8_t *)&peer_enclave_identity->mr_signer, (uint8_t*)&g_initiator_mrsigner, sizeof(sgx_measurement_t)))
        return ENCLAVE_TRUST_ERROR;
    
    // 检查对等Enclave的产品ID和属性（应已初始化）
    if (peer_enclave_identity->isv_prod_id != 0 || !(peer_enclave_identity->attributes.flags & SGX_FLAGS_INITTED))
        return ENCLAVE_TRUST_ERROR;
    
    // 检查Enclave未以调试模式加载，除非项目是为调试目的构建的
    #if defined(NDEBUG)
    if (peer_enclave_identity->attributes.flags & SGX_FLAGS_DEBUG)
        return ENCLAVE_TRUST_ERROR;
    #endif

    return SUCCESS; // 验证成功
}

/* 函数描述：操作输入秘密并生成输出秘密 */
uint32_t get_message_exchange_response(uint32_t inp_secret_data)
{
    uint32_t secret_response;
    // 用户应使用更复杂的加密方法来保护他们的秘密，下面的例子只是一个简单的示例
    secret_response = inp_secret_data & 0x11111111;
    return secret_response;
}

/* 函数描述：从请求消息生成响应
 * 参数描述：
 * [输入] decrypted_data: 指向解密数据的指针
 * [输出] resp_buffer: 指向响应消息的指针，缓冲区在本函数中分配
 * [输出] resp_length: 指向响应长度的指针
 * */
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; // 成功返回
}

功能分析
验证对等Enclave身份 verify_peer_enclave_trust：
功能：验证对等Enclave的身份以确保其可信度。
实现：检查输入参数 peer_enclave_identity 是否为空，避免空指针错误。
检查对等Enclave的MRSIGNER是否符合预期（预留代码，实际使用需要取消注释）。
检查对等Enclave的产品ID和属性，确保Enclave已初始化且未设置DEBUG属性。
如果项目是非调试配置，检查Enclave未以调试模式加载。
验证成功则返回 SUCCESS，否则返回适当的错误码。
生成消息交换响应 get_message_exchange_response：
功能：根据输入数据生成响应数据。
实现：对输入数据进行简单的按位与操作生成响应数据（实际使用中应使用更复杂的加密方法保护秘密数据）。返回生成的响应数据。
处理请求消息并生成响应 message_exchange_response_generator：
功能：从请求消息生成响应消息。
实现：检查输入的解密数据和响应长度指针是否为空，确保有有效输入。将解密数据转换为消息交换结构体。解组请求消息以获取输入秘密数据。调用 get_message_exchange_response 生成响应数据。序列化响应数据到缓冲区。返回成功状态或适当的错误码。代码相关性和用途，这段代码用于在SGX Enclave环境中实现本地认证的响应者端。通过验证对等Enclave的身份，确保通信双方的可信度。处理消息交换请求并生成相应的响应，以确保安全通信和数据交换。
注意事项
在实际项目中，应根据实际情况启用对MRSIGNER的检查，以增强安全性。加密方法应根据实际需求进行调整，以确保数据的安全性和完整性。

• EnclaveResponder.edl

enclave {
    include "sgx_eid.h"
    include "datatypes.h"
    include "../Include/dh_session_protocol.h"
    trusted{
            public uint32_t session_request([out] sgx_dh_msg1_t *dh_msg1, [out] uint32_t *session_id);
            public uint32_t exchange_report([in] sgx_dh_msg2_t *dh_msg2, [out] sgx_dh_msg3_t *dh_msg3, uint32_t session_id);
            public uint32_t generate_response([in, size = req_message_size] secure_message_t* req_message, size_t req_message_size, size_t max_payload_size, [out, size=resp_message_size] secure_message_t* resp_message, size_t resp_message_size, uint32_t session_id);
            public uint32_t end_session(uint32_t session_id);
    };

};

2.3 编译执行

2.3.1 Makefile文件分析

include buildenv.mk
# 包含外部的环境变量定义文件 buildenv.mk。

# 根据 SGX_MODE 和相关标志设置 Build_Mode 的变量。
# 如果 SGX_MODE 是硬件模式 (HW), 则根据 SGX_DEBUG 和 SGX_PRERELEASE 决定具体的构建模式。
ifeq ($(SGX_MODE), HW)
ifeq ($(SGX_DEBUG), 1)
		Build_Mode = HW_DEBUG
else ifeq ($(SGX_PRERELEASE), 1)
		Build_Mode = HW_PRERELEASE
else
		Build_Mode = HW_RELEASE
endif
endif
# 如果 SGX_MODE 是仿真模式 (SIM), 同样根据 SGX_DEBUG 和 SGX_PRERELEASE 决定具体的构建模式。
ifeq ($(SGX_MODE), SIM)
ifeq ($(SGX_DEBUG), 1)
		Build_Mode = SIM_DEBUG
else ifeq ($(SGX_PRERELEASE), 1)
		Build_Mode = SIM_PRERELEASE
else
		Build_Mode = SIM_RELEASE
endif
endif

# 定义子目录列表，包含 AppInitiator, AppResponder, EnclaveInitiator, EnclaveResponder 和 App。
SUB_DIR := AppInitiator AppResponder EnclaveInitiator EnclaveResponder App

# 如果 OUTDIR 变量不为空，创建输出目录。
ifneq ($(OUTDIR),)
$(shell mkdir -p $(OUTDIR))
endif

# 定义伪目标 all 和 clean。伪目标不会被当作实际文件处理。
.PHONY: all clean

# all规则，构建每个子目录中的目标。
# 根据不同的构建模式，输出对应的构建模式信息。
all:
	for dir in $(SUB_DIR); do \
		$(MAKE) -C $$dir; \
	done
ifeq ($(Build_Mode), HW_DEBUG)
	@echo "The project has been built in hardware debug mode."
else ifeq ($(Build_Mode), HW_RELEAESE)
	@echo "The project has been built in hardware release mode."
else ifeq ($(Build_Mode), HW_PRERELEAESE)
	@echo "The project has been built in hardware pre-release mode."
else ifeq ($(Build_Mode), SIM_DEBUG)
	@echo "The project has been built in simulation debug mode."
else ifeq ($(Build_Mode), SIM_RELEAESE)
	@echo "The project has been built in simulation release mode."
else ifeq ($(Build_Mode), SIM_PRERELEAESE)
	@echo "The project has been built in simulation pre-release mode."
endif

# clean规则，删除输出目录，然后清理每个子目录中的目标文件，并删除 util 目录下的所有 .o 文件。
clean:
	@rm -rf $(OUTDIR)
	for dir in $(SUB_DIR); do \
		$(MAKE) -C $$dir clean; \
	done
	rm -f util/*.o

    注意，该Makefile文件依赖于另外一个buildenv.mk文件以及会调用各个目录下的子Makefile文件（App、AppInitiator、AppResponder、EnclaveInitiator、EnclaveResponder），在这些依赖Makefile文件中定义了一些环境变量的值，以及当前目录下编译的方法，此处不再细节展开。
    直接执行make编译。

2.3.2 执行

• 单线程执行，也即一个进程完成全部本地认证流程（即充当发起者也充当响应者）；

./app
succeed to load enclaves.
succeed to establish secure channel.
Succeed to exchange secure message...
Succeed to close Session...

• 双线程执行（一个线程充当发起者appinitiator ，另一个线程充当响应者appresponder）

当响应者进程先启动时：

./appresponder 
Server is ON...
Press Ctrl+C to exit...

启动发起者进程会成功认证并输出如下：

./appinitiator 
succeed to load enclave libenclave_initiator.signed.so
succeed to establish secure channel.
Succeed to exchange secure message...
Succeed to close Session...

但是在没有启动响应者进程的情况下，七点发起者进程会认证失败并输出如下（主要是connection error）：

./appinitiator 
succeed to load enclave libenclave_initiator.signed.so
connection error, Connection refused, line 80.
fail to send and receive message.
failed to establish secure channel: ECALL return 0x0, error code is 0xe3.

2.4 总结

    在本地认证（Local Attestation）过程中，SGX Enclave间通过相互认证以确保彼此的可信性。以下是工程中主要代码模块之间的调用和交互关系的总结。

1. 项目结构: 一个典型的SGX Local Attestation项目通常包括以下主要模块：
   AppInitiator：发起本地认证请求的应用程序。
   AppResponder：响应本地认证请求的应用程序。
   EnclaveInitiator：包含发起本地认证的逻辑的Enclave。
   EnclaveResponder：包含响应本地认证的逻辑的Enclave。

2. 流程图概述

AppInitiator  <====>  EnclaveInitiator
    |
    V
AppResponder  <====>  EnclaveResponder

3. 具体流程说明
   3.1 初始化阶段
   加载Enclave：
   AppInitiator和AppResponder分别调用sgx_create_enclave函数加载各自的Enclave。
   EnclaveInitiator和EnclaveResponder在加载后各自初始化所需的数据和上下文。
   3.2 会话创建阶段
   发起者创建会话请求：
   AppInitiator通过调用test_create_session函数发起会话创建请求，ECALL进入EnclaveInitiator。
   EnclaveInitiator调用create_session函数，生成会话密钥并保存会话上下文（dh_session_t）。
   发送会话请求到响应者：
   EnclaveInitiator通过OCALL接口session_request_ocall将会话请求消息（包含ECDH消息1）发送给AppResponder。
   3.3 会话处理阶段
   处理会话请求：
   AppResponder接收会话请求消息后，通过OCALL接口调用EnclaveResponder的session_request函数。
   EnclaveResponder生成响应消息（包含ECDH消息2和Session ID），并通过OCALL接口exchange_report_ocall返回给AppInitiator。
   处理会话响应：
   AppInitiator接收到会话响应消息后，通过ECALL接口调用EnclaveInitiator的exchange_report函数。
   EnclaveInitiator处理会话响应消息，生成会话密钥并保存上下文。
   3.4 消息交换阶段
   发送消息：
   AppInitiator调用test_message_exchange函数，通过ECALL进入EnclaveInitiator。
   EnclaveInitiator通过OCALL接口send_request_receive_response发送消息请求到AppResponder。
   处理消息请求：
   AppResponder接收消息请求后，通过OCALL接口调用EnclaveResponder的generate_response函数。
   EnclaveResponder处理消息并生成响应消息，返回给AppInitiator。
   接收消息响应：
   AppInitiator接收到消息响应后，EnclaveInitiator处理响应数据，完成一次消息交换。
   3.5 会话关闭阶段
   关闭会话：
   AppInitiator调用test_close_session函数，通过ECALL进入EnclaveInitiator。
   EnclaveInitiator调用close_session函数关闭会话，并通过OCALL接口end_session_ocall通知AppResponder。
   处理会话关闭请求：
   AppResponder接收会话关闭请求后，通过OCALL接口调用EnclaveResponder的end_session函数销毁会话。

4. 代码模块交互
   以下是各主要模块的调用关系：
   4.1 AppInitiator/Main.cpp 调用 sgx_create_enclave 初始化 EnclaveInitiator。
   4.2 EnclaveInitiator 有以下交互：
   ECALL：test_create_session 创建会话。
   OCALL：session_request_ocall 从 AppResponder 获取会话响应。
   处理会话响应的 OCALL：exchange_report_ocall。
   ECALL：test_message_exchange 发送消息并接收响应。
   处理消息交换的 OCALL：send_request_receive_response。
   ECALL：test_close_session 关闭会话。
   处理会话关闭的 OCALL：end_session_ocall。
   4.3 AppResponder/Main.cpp 调用 sgx_create_enclave 初始化 EnclaveResponder。
   4.4 EnclaveResponder 有以下交互：
   OCALL：generate_and_send_session_msg1_resp 生成并发送会话消息1。
   处理会话请求的 OCALL：process_exchange_report。
   处理消息交换请求的 OCALL：process_msg_transfer。
   处理会话关闭请求的 OCALL：process_close_req。

三.参考文献

Innovative Technology for CPU Based Attestation and Sealing论文翻译
王进文, 江勇, 李琦, 等. SGX 技术应用研究综述[J]. 网络新媒体技术, 2017, 6(5): 3-9.

四.感谢支持

    完结撒花！后续将持续输出，形成Intel SGX的系列教程，并结合密码学算法设计更复杂功能。希望看到这里的小伙伴能点个关注，也欢迎志同道合的小伙伴一起广泛交流。
    码字实属不易，如果本文对你有10分帮助，就赏个10分把，感谢各位大佬支持！