【SGX系列教程】（五）enclave多线程测试，以及EPC内存测试

一. 概述

    在Intel SGX环境下，多线程的实现主要依赖于SGX SDK提供的功能以及传统的线程库（如Pthreads）。本质上来说多线程是在Enclave外部创建的，然后每个线程分别调用ECALL进入Enclave执行。而直接在Enclave内部创建多线程并不被SGX直接支持，因为Enclave的设计初衷是为了保持安全性和隔离性，尽量减少复杂性。因此，传统的多线程管理（如线程创建、调度等）通常在外部进行，然后在Enclave内部利用这些外部线程来并行执行任务。

    尽管SGX本身不支持在Enclave内部直接创建线程，但可以通过以下方法来模拟这种效果：

1. 通过多个ECALLs并行执行任务：

• 在外部创建多个线程，每个线程调用不同的ECALL来执行不同的任务。
• 在Enclave内部，通过线程同步机制（如Mutex，Condition Variable）来管理这些任务。

2. 线程池机制：

• 在Host中实现一个线程池，预先创建多个线程，这些线程在需要时调用Enclave中的相应ECALL进行任务处理。

二. 原理分析

2.1 多线程在Enclave中的实现流程

1. 线程上下文（Thread Context）
   每个线程在进入Enclave时会创建一个新的线程上下文。SGX维护一个线程控制结构（TCS），每个TCS与一个特定的线程绑定。这意味着每个进入Enclave的线程必须有一个相应的TCS。

2. 线程控制结构（TCS）
   TCS（Thread Control Structure）是Enclave的关键数据结构，用于管理线程上下文。
   在创建Enclave时，开发人员必须指定Enclave中允许的TCS数量（在Enclave.config.xml中设置，后面会讲）。这决定了可以同时在Enclave中执行的线程数量。

3. ECALL与OCALL
   ECALL（Enclave Call）：从Host调用进入Enclave的受保护函数。
   OCALL（Outside Call）：从Enclave调用Host的外部函数。OCALL的实现通常涉及Host代码中的多线程处理。

4. 线程同步
   Enclave提供了基本的线程同步原语，如互斥锁（Mutex）和条件变量（Condition Variable）。这些原语类似于Pthreads库中的相应功能，但实现上需要考虑安全性和性能。

2.2 多线程和EPC内存分配之间的冲突

1. EPC（Enclave Page Cache）内存限制
   EPC是SGX的关键资源，用于存储Enclave的代码和数据。
   每个系统的EPC大小是有限的，典型大小为128MB（不包括系统预留和管理开销）。
2. 多线程对EPC的影响
   每个线程进入Enclave都会消耗一定量的EPC内存，主要用于TCS和线程堆栈。
   多线程运行时，多个线程同时访问和分配EPC内存，这可能会导致EPC内存不足。
3. EPC内存分配失败的原因
   内存碎片化：频繁的内存分配和释放可能导致EPC内存碎片化，虽然总内存可能足够，但无法找到连续的内存块进行分配。
   线程堆栈大小：每个线程的堆栈大小设置过大可能导致EPC内存快速消耗。
   并发内存分配：多线程同时分配大量内存时，可能会导致EPC内存分配冲突。

2.3 解决多线程和EPC内存分配冲突的策略

1. 减少线程数量
   尽量减少同时在Enclave中运行的线程数量。
   优化TCS数量，确保足够但不浪费。
2. 优化内存分配
   内存池：使用内存池技术预先分配和管理内存，减少碎片化。
   内存复用：重用已经分配的内存，减少频繁的分配和释放操作。
3. 调整堆栈和堆大小
   根据应用需求合理设置堆栈和堆的大小（在Enclave.config.xml中设置，后面会讲），避免过大的默认值。
   在Enclave配置文件中合理配置堆栈和堆大小。

三. 源码分析

3.1 代码结构

multi_enclave_thread/
├── App
│   ├── App.cpp
│   └── App.h
│   ├── ErrorSupport.cpp
│   └── ErrorSupport.h
│   └── Thread.cpp              # 多线程主程序
├── Enclave
│   ├── Enclave.config.xml      # 配置文件
│   ├── Enclave.cpp
│   ├── Enclave.edl
│   ├── Thread.cpp              # 多线程ecall程序
│   ├── Thread.edl              # 多线程ecall函数接口
│   ├── Enclave.h
│   ├── Enclave.lds
│   └── Enclave_private.pem
├── Include
└── Makefile

3.2 源码

3.2.1 App文件夹

• App.cpp

#include <stdio.h>
#include <string.h>
#include <vector>
#include <thread>
#include <iostream>
#include "sgx_urts.h"
#include "App.h"
#include "Enclave_u.h"
#include "ErrorSupport.h"

#define MAX_PATH FILENAME_MAX

/* Global EID shared by multiple threads */
sgx_enclave_id_t global_eid = 0;

/* OCall函数，给ECALL函数调用，打印输出 */
void ocall_print_string(const char *str)
{
    printf("%s", str); /* 代理将会检查字符串的长度并在结尾添加空字符，防止缓冲区溢出 */
}

// 定义OCALL，延时us
void ocall_host_sleep_microseconds(int microseconds) {
    std::this_thread::sleep_for(std::chrono::microseconds(microseconds));
}
// 定义OCALL，延时ms
void ocall_host_sleep_milliseconds(int milliseconds) {
    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
}

/* 应用程序入口 */
int SGX_CDECL main(int argc, char *argv[])
{
    (void)(argc);
    (void)(argv);

    // 调用 sgx_create_enclave 创建一个 Enclave 实例
    sgx_status_t ret = SGX_ERROR_UNEXPECTED;   // 定义函数返回值
    ret = sgx_create_enclave(ENCLAVE_FILENAME, SGX_DEBUG_FLAG, NULL, NULL, &global_eid, NULL); 
    if (ret != SGX_SUCCESS) {
        printf("创建enclave失败, 错误码为: %d\n", ret);
        ret_error_support(ret);   // 打印具体的错误信息
        return -1;
    }

    // 测试1,2: 多线程下生产者、消费者测试，主要用到mutex互斥锁和cond信号量
    ecall_thread_functions();       
    // 测试3: 多线程下内存消耗测试
    test_memory_consumption(1);    // 单线程测试
    // test_memory_consumption(2); // 2线程测试
    // test_memory_consumption(4); // 4线程测试
    // test_memory_consumption(5); // 8线程测试

    /* 销毁 Enclave */
    sgx_destroy_enclave(global_eid);

    return 0;
}

• App.h

#ifndef _APP_H_
#define _APP_H_

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "sgx_error.h"       /* sgx_status_t */
#include "sgx_eid.h"     /* sgx_enclave_id_t */
#include <cstdio>   // Add this line for printf and getchar

#ifndef TRUE
# define TRUE 1
#endif

#ifndef FALSE
# define FALSE 0
#endif

# define TOKEN_FILENAME   "enclave.token"
# define ENCLAVE_FILENAME "enclave.signed.so"

extern sgx_enclave_id_t global_eid;    /* global enclave id */

#if defined(__cplusplus)
extern "C" {
#endif

void ecall_thread_functions(void);
void test_memory_consumption(int num_threads);

#if defined(__cplusplus)
}
#endif

#endif /* !_APP_H_ */

• Thread.cpp

#include <thread>        // 包含标准C++线程库头文件
#include <iostream>      // 包含标准C++线程库头文件
#include <vector>        // 包含标准C++线程库头文件
#include <stdio.h>       // 包含标准输入输出头文件
#include "App.h"         // 包含应用程序的头文件
#include "Enclave_u.h"   // 包含Enclave生成的头文件，用于与Enclave进行交互

using namespace std;     // 使用标准命名空间

/*******************************测试1：多线程互斥锁、信号量测试****************************************/
static size_t counter = 0;  // 全局计数器
/* 增加计数器的函数 */
void increase_counter(void)
{
    size_t cnr = 0;
    sgx_status_t ret = SGX_ERROR_UNEXPECTED;
    ret = ecall_increase_counter(global_eid, &cnr);  // 调用ECALL增加计数器
    if (cnr != 0) counter = cnr;                     // 如果cnr不为0，更新全局计数器
    if (ret != SGX_SUCCESS)
        abort();  // 如果调用失败，终止程序
}
/* 数据生产者函数 */
void data_producer(void)
{
    sgx_status_t ret = SGX_ERROR_UNEXPECTED;
    ret = ecall_producer(global_eid);  // 调用ECALL数据生产者
    if (ret != SGX_SUCCESS)
        abort();  // 如果调用失败，终止程序
}
/* 数据消费者函数 */
void data_consumer(void)
{
    sgx_status_t ret = SGX_ERROR_UNEXPECTED;
    ret = ecall_consumer(global_eid);  // 调用ECALL数据消费者
    if (ret != SGX_SUCCESS)
        abort();  // 如果调用失败，终止程序
}

/* ecall_thread_functions:
 * 调用线程函数，包括互斥锁、条件变量等。
 */
void ecall_thread_functions(void)
{
    // 创建和启动四个增加计数器的线程
    thread adder1(increase_counter);
    thread adder2(increase_counter);
    thread adder3(increase_counter);
    thread adder4(increase_counter);
    // 等待所有线程完成，回收线程
    adder1.join();
    adder2.join();
    adder3.join();
    adder4.join();

    if(counter == 4 * LOOPS_PER_THREAD)
        std::cout<<"多线程计数器测试通过＜（＾－＾）＞"<<std::endl;
    else
        std::cout<<"多线程计数器测试不通过/(ㄒoㄒ)/~~"<<std::endl;

    // 确认计数器的值是否符合预期
    assert(counter == 4 * LOOPS_PER_THREAD);

    // 创建和启动消费和生产线程
    thread consumer1(data_consumer);
    thread producer0(data_producer);
    thread consumer2(data_consumer);
    thread consumer3(data_consumer);
    thread consumer4(data_consumer);
    // 等待所有线程完成，回收线程
    consumer1.join();
    consumer2.join();
    consumer3.join();
    consumer4.join();
    producer0.join();
}

/*******************************测试2：多线程内存消耗测试****************************************/
// 线程具体执行函数，其中thread_num表示开启的线程数，而times表示当前调用的线程号
void thread_task(sgx_enclave_id_t eid, int thread_num,int times) {
    ecall_thread_test(eid,thread_num,times);
}
// 测试多线程调用ecall函数，也就是在REE中开了多线程，各个线程分别调用ecall函数
void test_memory_consumption(int num_threads) {
    std::vector<std::thread> threads;
    auto start = std::chrono::high_resolution_clock::now();  // 计算起始时间
    // 开启多线程执行，传入的是具体的线程函数、enclave id、当前的线程数（为了给不同的线程数下分配不同内存大小）、当前线程号
    for (int i = 1; i <= num_threads; ++i) {
        threads.emplace_back(thread_task, global_eid, num_threads, i);
    }
    // 多线程回收
    for (auto& t : threads) {
        t.join();
    }
    auto end = std::chrono::high_resolution_clock::now();   // 计算结束时间
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start); 
    std::cout << "Time taken with " << num_threads << " threads: " << duration.count() << " ms." << std::endl;
}

3.2.2 Enclave文件夹

• Enclave.config.xml

<EnclaveConfiguration>
  <ProdID>0</ProdID>                      <!-- 生产者ID，通常用于标识该Enclave所属的产品。这在调试和开发阶段通常为0 -->
  <ISVSVN>0</ISVSVN>                      <!-- 软件版本号，用于标识当前Enclave的版本号。通常用于版本管理和更新控制 -->
  <StackMaxSize>0x40000</StackMaxSize>    <!-- 最大栈空间大小：256KB, 可根据需求调整 -->
  <HeapMaxSize>0x8000000</HeapMaxSize>    <!-- 最大堆空间大小：128MB -->
  <TCSNum>10</TCSNum>                     <!-- 线程控制结构（TCS）的数量，设置为10，TCS用于管理Enclave中的线程 -->
  <TCSPolicy>1</TCSPolicy>                <!-- TCS策略，1表示允许动态分配 -->
  <!-- Recommend changing 'DisableDebug' to 1 to make the enclave undebuggable for enclave release -->
  <DisableDebug>0</DisableDebug>          <!-- 调试开关，0表示启用调试，1表示禁用调试。调试阶段通常设置为0，发布阶段建议设置为1 -->      
  <MiscSelect>0</MiscSelect>              <!-- 杂项选择，0表示不选择任何杂项功能 -->  
  <MiscMask>0xFFFFFFFF</MiscMask>         <!-- 杂项掩码，0xFFFFFFFF表示启用所有可用的杂项功能 -->  
</EnclaveConfiguration>     

• Enclave.cpp

#include "Enclave.h"
#include "Enclave_t.h"  /* print_string */
#include "sgx_trts.h"
#include <stdio.h>      /* vsnprintf */
#include <string.h>
#include <vector>   
#include <string>

// Invokes OCALL to display the enclave buffer to the terminal.
int printf(const char* fmt, ...)
{
    char buf[BUFSIZ] = { '\0' };
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, BUFSIZ, fmt, ap);
    va_end(ap);
    ocall_print_string(buf);
    return (int)strnlen(buf, BUFSIZ - 1) + 1;
}

• Enclave.h

#ifndef _ENCLAVE_H_
#define _ENCLAVE_H_
int printf(const char* fmt, ...);
#endif

• Thread.cpp

#include "Enclave.h"
#include "Enclave_t.h"
#include "sgx_thread.h"
#include <vector>
#include <algorithm>

/********************************************测试1：多线程计数器测试，主要测试mutex互斥锁***************************************************/
static size_t global_counter = 0; // 全局计数器
static sgx_thread_mutex_t global_mutex = SGX_THREAD_MUTEX_INITIALIZER; // 全局互斥锁
/*
 * ecall_increase_counter: 增加计数至LOOPS_PER_THREAD
 *   在enclave中使用线程API。
 */
size_t ecall_increase_counter(void)
{
    size_t ret = 0;
    for (int i = 0; i < LOOPS_PER_THREAD; i++) {
        sgx_thread_mutex_lock(&global_mutex);   // 加锁
        /* 互斥地增加计数器 */
        size_t tmp = global_counter;
        global_counter = ++tmp;
        if (4*LOOPS_PER_THREAD == global_counter)
            ret = global_counter;
        sgx_thread_mutex_unlock(&global_mutex); // 解锁
    }
    return ret;
}

/*******************************测试1,2：多线程下生产者、消费者测试，主要用到mutex互斥锁和cond信号量*****************************************/
#define BUFFER_SIZE 50 // 缓冲区大小

typedef struct {
    int buf[BUFFER_SIZE];       // 缓冲区数组
    int occupied;               // 已占用的缓冲区数量
    int nextin;                 // 下一个写入位置
    int nextout;                // 下一个读取位置
    sgx_thread_mutex_t mutex;   // 互斥锁
    sgx_thread_cond_t more;     // 条件变量，表示有更多数据
    sgx_thread_cond_t less;     // 条件变量，表示有更少数据
} cond_buffer_t;

// 定义一个全局变量，供producer和consumer共用
static cond_buffer_t buffer = {{0, 0, 0, 0, 0, 0}, 0, 0, 0,
    SGX_THREAD_MUTEX_INITIALIZER, SGX_THREAD_COND_INITIALIZER, SGX_THREAD_COND_INITIALIZER}; // 初始化缓冲区

// 生产者线程调用：生产4*LOOPS_PER_THREAD个消息
void ecall_producer(void)
{
    for (int i = 0; i < 4*LOOPS_PER_THREAD; i++) {
        cond_buffer_t *b = &buffer;
        sgx_thread_mutex_lock(&b->mutex);   // 加锁
        while (b->occupied >= BUFFER_SIZE)
            sgx_thread_cond_wait(&b->less, &b->mutex); // 等待缓冲区有空闲空间
        b->buf[b->nextin] = b->nextin;      // 写入数据
        b->nextin++;
        b->nextin %= BUFFER_SIZE;   // 循环使用缓冲区
        b->occupied++;              // 增加占用计数
        sgx_thread_cond_signal(&b->more); // 通知消费者有更多数据
        sgx_thread_mutex_unlock(&b->mutex); // 解锁
    }
}

// 消费者线程调用：消费LOOPS_PER_THREAD个消息
void ecall_consumer(void)
{
    for (int i = 0; i < LOOPS_PER_THREAD; i++) {
        cond_buffer_t *b = &buffer;         // 使用全局变量
        sgx_thread_mutex_lock(&b->mutex);   // 加锁
        while(b->occupied <= 0)
            sgx_thread_cond_wait(&b->more, &b->mutex); // 等待缓冲区有数据
        b->buf[b->nextout++] = 0;                      // 读取数据
        b->nextout %= BUFFER_SIZE;  // 循环使用缓冲区
        b->occupied--;              // 减少占用计数
        sgx_thread_cond_signal(&b->less); // 通知生产者有空闲空间
        sgx_thread_mutex_unlock(&b->mutex); // 解锁
    }
}

/********************************************测试3：多线程下内存消耗测试***************************************************/
const size_t TOTAL_MEMORY = 96 * 1024 * 1024;   // 总的分配内存 96MB
const size_t CHUNK_SIZE = 256 * 1024;           // 一次性malloc分配的块大小 256KB

// 具体执行函数
void memory_intensive_multi_thread(size_t thread_num,int times) {
    size_t total_memory_to_assign = TOTAL_MEMORY / thread_num;        // 计算需要分配的总内存大小
    size_t num_chunks = total_memory_to_assign / CHUNK_SIZE;          // 计算CHUNK的数量
    std::vector<unsigned char*> allocated_chunks;
    for (size_t i = 0; i < num_chunks; ++i) {
        unsigned char* ptr;       
        while((ptr=(unsigned char*)malloc(CHUNK_SIZE))==nullptr)      // 分配CHUNK_SIZE大小内存空间给ptr
        {
            printf("内存分配失败...\n");
            ocall_host_sleep_milliseconds(10);  // 延时10ms
        }
        if (ptr != nullptr) {                                          // 分配成功
            memset(ptr, 0x12, CHUNK_SIZE);
            allocated_chunks.push_back(ptr);
            // printf("第%d进程,第%d块,分配内存大小: %d KB, 内存值：\n",times,i,CHUNK_SIZE/1024); 
            ocall_host_sleep_milliseconds(1);  // 延时1ms,模拟enclave中的计算任务
        } else {
            printf("内存分配失败!\n");
        } 
    }
    for (unsigned char* ptr : allocated_chunks) {
        free(ptr);
    }
}

// thread_num表示当前的线程数，times表示第几个线程的运行
void ecall_thread_test(int thread_num,int times) {
    printf("enclave线程%d运行中....\n",times);
    memory_intensive_multi_thread(thread_num,times);
    printf("enclave线程%d运行结束....\n",times);
}

• Thread.edl

enclave {
    from "sgx_tstdc.edl" import sgx_thread_wait_untrusted_event_ocall, sgx_thread_set_untrusted_event_ocall, sgx_thread_setwait_untrusted_events_ocall, sgx_thread_set_multiple_untrusted_events_ocall;
    trusted {
        /*
         * Use SGX mutex.
         */
        public size_t ecall_increase_counter();
        /*
         * Use SGX condition variables.
         */
        public void ecall_producer();
        public void ecall_consumer();
        public void ecall_thread_test(int thread_num,int times);
    };
};

• Enclave.edl

enclave {
    include "user_types.h" /* buffer_t */

    from "Thread.edl" import *;

    trusted {

    };
    untrusted {
        void ocall_print_string([in, string] const char *str);
        void ocall_host_sleep_microseconds(int microseconds);
        void ocall_host_sleep_milliseconds(int milliseconds);
    };
};

3.2.3 Makefile

######## SGX SDK Settings ########
# 设置 SGX SDK 的路径、模式、架构和调试选项
# SGX SDK 安装路径
SGX_SDK ?= /opt/intel/sgxsdk
# SGX 模式：硬件模式(HW)
SGX_MODE ?= HW
# SGX 架构：64 位(x64)
SGX_ARCH ?= x64
# SGX 调试模式：启用(1)
SGX_DEBUG ?= 1

# 判断系统的位数，如果是 32 位，设置架构为 x86
ifeq ($(shell getconf LONG_BIT), 32)
    SGX_ARCH := x86
# 如果编译器标志中包含 -m32，也设置架构为 x86
else ifeq ($(findstring -m32, $(CXXFLAGS)), -m32)
    SGX_ARCH := x86
endif

# 根据架构选择编译器标志、库路径和工具路径
ifeq ($(SGX_ARCH), x86)
    SGX_COMMON_FLAGS := -m32                         # 设置 32 位编译标志
    SGX_LIBRARY_PATH := $(SGX_SDK)/lib               # 32 位库路径
    SGX_ENCLAVE_SIGNER := $(SGX_SDK)/bin/x86/sgx_sign # 使用 32 位签名工具
    SGX_EDGER8R := $(SGX_SDK)/bin/x86/sgx_edger8r     # 使用 32 位 Edger8r 工具
else
    SGX_COMMON_FLAGS := -m64                         # 设置 64 位编译标志
    SGX_LIBRARY_PATH := $(SGX_SDK)/lib64             # 64 位库路径
    SGX_ENCLAVE_SIGNER := $(SGX_SDK)/bin/x64/sgx_sign # 使用 64 位签名工具
    SGX_EDGER8R := $(SGX_SDK)/bin/x64/sgx_edger8r     # 使用 64 位 Edger8r 工具
endif

# 检查是否同时设置了调试模式和预发布模式
ifeq ($(SGX_DEBUG), 1)
ifeq ($(SGX_PRERELEASE), 1)
$(error Cannot set SGX_DEBUG and SGX_PRERELEASE at the same time!!)
# 如果两个都设置了，报错 "不能同时设置调试模式和预发布模式"
endif
endif

# 根据是否启用调试模式设置编译标志
ifeq ($(SGX_DEBUG), 1)
        SGX_COMMON_FLAGS += -O0 -g  # 调试模式：不进行优化，包含调试信息
else
        SGX_COMMON_FLAGS += -O2    # 生产模式：优化代码
endif

# 设置更多的编译器警告标志，确保代码质量
SGX_COMMON_FLAGS += -Wall -Wextra -Winit-self -Wpointer-arith -Wreturn-type \
                    -Waddress -Wsequence-point -Wformat-security \
                    -Wmissing-include-dirs -Wfloat-equal -Wundef -Wshadow \
                    -Wcast-align -Wcast-qual -Wconversion -Wredundant-decls
SGX_COMMON_CFLAGS := $(SGX_COMMON_FLAGS) -Wjump-misses-init -Wstrict-prototypes -Wunsuffixed-float-constants # C 编译标志
SGX_COMMON_CXXFLAGS := $(SGX_COMMON_FLAGS) -Wnon-virtual-dtor -std=c++11  # C++ 编译标志，使用 C++11 标准

######## App Settings ########

# 应用程序设置
ifneq ($(SGX_MODE), HW)
    Urts_Library_Name := sgx_urts_sim  # 如果不是硬件模式，使用仿真库
else
    Urts_Library_Name := sgx_urts      # 如果是硬件模式，使用真实库
endif

# 指定应用程序的源文件和包含路径
App_Cpp_Files := $(wildcard App/*.cpp)
App_Include_Paths := -IInclude -IApp -I$(SGX_SDK)/include

# 设置应用程序的编译标志
App_C_Flags := -fPIC -Wno-attributes $(App_Include_Paths)

# 根据不同的配置模式，设置不同的宏定义
# Three configuration modes - Debug, prerelease, release
#   Debug - Macro DEBUG enabled.
#   Prerelease - Macro NDEBUG and EDEBUG enabled.
#   Release - Macro NDEBUG enabled.
ifeq ($(SGX_DEBUG), 1)
        App_C_Flags += -DDEBUG -UNDEBUG -UEDEBUG
else ifeq ($(SGX_PRERELEASE), 1)
        App_C_Flags += -DNDEBUG -DEDEBUG -UDEBUG
else
        App_C_Flags += -DNDEBUG -UEDEBUG -UDEBUG
endif

App_Cpp_Flags := $(App_C_Flags)
App_Link_Flags := -L$(SGX_LIBRARY_PATH) -l$(Urts_Library_Name) -lpthread 

# 生成对象文件的规则
App_Cpp_Objects := $(App_Cpp_Files:.cpp=.o)
# 指定生成的应用程序名称
App_Name := app

######## Enclave Settings ########
# 设置信任域版本脚本文件根据调试模式与硬件模式判断
Enclave_Version_Script := Enclave/Enclave.lds
ifeq ($(SGX_MODE), HW)
ifneq ($(SGX_DEBUG), 1)
ifneq ($(SGX_PRERELEASE), 1)
	# 硬件发布模式下使用的版本脚本文件
	# Choose to use 'Enclave.lds' for HW release mode
	Enclave_Version_Script = Enclave/Enclave.lds 
endif
endif
endif

# 仿真模式与硬件模式下使用不同的库
ifneq ($(SGX_MODE), HW)
    Trts_Library_Name := sgx_trts_sim      # 仿真模式库
    Service_Library_Name := sgx_tservice_sim # 仿真模式服务库
else
    Trts_Library_Name := sgx_trts         # 硬件模式库
    Service_Library_Name := sgx_tservice  # 硬件模式服务库
endif
Crypto_Library_Name := sgx_tcrypto        # 加密库

# 指定信任域的源文件和包含路径
Enclave_Cpp_Files := $(wildcard Enclave/*.cpp)
Enclave_Include_Paths := -IInclude -IEnclave -I$(SGX_SDK)/include -I$(SGX_SDK)/include/libcxx -I$(SGX_SDK)/include/tlibc 

# 设置信任域的编译标志
Enclave_C_Flags := -nostdinc -fvisibility=hidden -fpie -fstack-protector -fno-builtin-printf $(Enclave_Include_Paths)
Enclave_Cpp_Flags := $(Enclave_C_Flags) -nostdinc++

# 启用安全链接选项
Enclave_Security_Link_Flags := -Wl,-z,relro,-z,now,-z,noexecstack

# 生成信任域的正确链接规则
# 按步骤链接信任库
Enclave_Link_Flags := $(Enclave_Security_Link_Flags) \
    -Wl,--no-undefined -nostdlib -nodefaultlibs -nostartfiles -L$(SGX_LIBRARY_PATH) \
	-Wl,--whole-archive -l$(Trts_Library_Name) -Wl,--no-whole-archive \
	-Wl,--start-group -lsgx_tstdc -lsgx_tcxx -l$(Crypto_Library_Name) -l$(Service_Library_Name) -Wl,--end-group \
	-Wl,-Bstatic -Wl,-Bsymbolic -Wl,--no-undefined \
	-Wl,-pie,-eenclave_entry -Wl,--export-dynamic  \
	-Wl,--defsym,__ImageBase=0 \
	-Wl,--version-script=$(Enclave_Version_Script)
# 指定信任域生成的对象文件
Enclave_Cpp_Objects := $(Enclave_Cpp_Files:.cpp=.o)
# 指定生成的信任域库名
Enclave_Name := enclave.so
Signed_Enclave_Name := enclave.signed.so
# 配置文件和测试密钥文件
Enclave_Config_File := Enclave/Enclave.config.xml
Enclave_Key := Enclave/Enclave_private.pem

# 生成不同的构建模式名称
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
else
ifeq ($(SGX_DEBUG), 1)
	Build_Mode = SIM_DEBUG
else ifeq ($(SGX_PRERELEASE), 1)
	Build_Mode = SIM_PRERELEASE
else
	Build_Mode = SIM_RELEASE
endif
endif


.PHONY: all run target
all: .config_$(Build_Mode)_$(SGX_ARCH)
	@$(MAKE) target

ifeq ($(Build_Mode), HW_RELEASE)
target: $(App_Name) $(Enclave_Name)
	@echo "The project has been built in release hardware mode."
	@echo "Please sign the $(Enclave_Name) first with your signing key before you run the $(App_Name) to launch and access the enclave."
	@echo "To sign the enclave use the command:"
	@echo "   $(SGX_ENCLAVE_SIGNER) sign -key <your key> -enclave $(Enclave_Name) -out <$(Signed_Enclave_Name)> -config $(Enclave_Config_File)"
	@echo "You can also sign the enclave using an external signing tool."
	@echo "To build the project in simulation mode set SGX_MODE=SIM. To build the project in prerelease mode set SGX_PRERELEASE=1 and SGX_MODE=HW."
else
target: $(App_Name) $(Signed_Enclave_Name)
ifeq ($(Build_Mode), HW_DEBUG)
	@echo "The project has been built in debug hardware mode."
else ifeq ($(Build_Mode), SIM_DEBUG)
	@echo "The project has been built in debug simulation mode."
else ifeq ($(Build_Mode), HW_PRERELEASE)
	@echo "The project has been built in pre-release hardware mode."
else ifeq ($(Build_Mode), SIM_PRERELEASE)
	@echo "The project has been built in pre-release simulation mode."
else
	@echo "The project has been built in release simulation mode."
endif
endif

# 运行目标规则，首先构建所有目标，然后运行应用程序，除非是在硬件发布模式下。
run: all
ifneq ($(Build_Mode), HW_RELEASE)
	@$(CURDIR)/$(App_Name)
	@echo "RUN  =>  $(App_Name) [$(SGX_MODE)|$(SGX_ARCH), OK]"
endif

# 配置文件生成规则，如果构建模式和架构改变，重新生成配置
.config_$(Build_Mode)_$(SGX_ARCH):
	@rm -f .config_* $(App_Name) $(Enclave_Name) $(Signed_Enclave_Name) $(App_Cpp_Objects) App/Enclave_u.* $(Enclave_Cpp_Objects) Enclave/Enclave_t.*
	@touch .config_$(Build_Mode)_$(SGX_ARCH)

######## App Objects ########

# 生成 Enclave_u.h，如果 Enclave.edl 改变
App/Enclave_u.h: $(SGX_EDGER8R) Enclave/Enclave.edl
	@cd App && $(SGX_EDGER8R) --untrusted ../Enclave/Enclave.edl --search-path ../Enclave --search-path $(SGX_SDK)/include
	@echo "GEN  =>  $@"

App/Enclave_u.c: App/Enclave_u.h

# 编译 Enclave_u.c 生成对象文件
App/Enclave_u.o: App/Enclave_u.c
	@$(CC) $(SGX_COMMON_CFLAGS) $(App_C_Flags) -c $< -o $@
	@echo "CC   <=  $<"

# 编译应用程序源文件生成对象文件
App/%.o: App/%.cpp App/Enclave_u.h
	@$(CXX) $(SGX_COMMON_CXXFLAGS) $(App_Cpp_Flags) -c $< -o $@
	@echo "CXX  <=  $<"

# 链接对象文件生成应用程序可执行文件
$(App_Name): App/Enclave_u.o $(App_Cpp_Objects)
	@$(CXX) $^ -o $@ $(App_Link_Flags)
	@echo "LINK =>  $@"

######## Enclave Objects ########
# 生成 Enclave_t.h，如果 Enclave.edl 改变
Enclave/Enclave_t.h: $(SGX_EDGER8R) Enclave/Enclave.edl
	@cd Enclave && $(SGX_EDGER8R) --trusted ../Enclave/Enclave.edl --search-path ../Enclave --search-path $(SGX_SDK)/include
	@echo "GEN  =>  $@"

Enclave/Enclave_t.c: Enclave/Enclave_t.h

# 编译 Enclave_t.c 生成对象文件
Enclave/Enclave_t.o: Enclave/Enclave_t.c
	@$(CC) $(SGX_COMMON_CFLAGS) $(Enclave_C_Flags) -c $< -o $@
	@echo "CC   <=  $<"

# 编译信任域源文件生成对象文件
Enclave/%.o: Enclave/%.cpp
	@$(CXX) $(SGX_COMMON_CXXFLAGS) $(Enclave_Cpp_Flags) -c $< -o $@
	@echo "CXX  <=  $<"

# 生成信任域对象文件
$(Enclave_Cpp_Objects): Enclave/Enclave_t.h

# 链接对象文件生成信任域共享库文件
$(Enclave_Name): Enclave/Enclave_t.o $(Enclave_Cpp_Objects)
	@$(CXX) $^ -o $@ $(Enclave_Link_Flags)
	@echo "LINK =>  $@"

# 使用测试私钥签名信任域共享库文件
$(Signed_Enclave_Name): $(Enclave_Name)
ifeq ($(wildcard $(Enclave_Key)),)
	@echo "There is no enclave test key<Enclave_private_test.pem>."
	@echo "The project will generate a key<Enclave_private_test.pem> for test."
	@openssl genrsa -out $(Enclave_Key) -3 3072
endif
	@$(SGX_ENCLAVE_SIGNER) sign -key $(Enclave_Key) -enclave $(Enclave_Name) -out $@ -config $(Enclave_Config_File)
	@echo "SIGN =>  $@"

# clean 目标，删除生成的文件
.PHONY: clean

clean:
	@rm -f .config_* $(App_Name) $(Enclave_Name) $(Signed_Enclave_Name) $(App_Cpp_Objects) App/Enclave_u.* $(Enclave_Cpp_Objects) Enclave/Enclave_t.*

3.3 总结

    在SGX中，直接在Enclave内部创建线程是不被支持的。我们可以通过在App中创建多线程，并利用ECALL机制在Enclave中执行并行任务来模拟这种效果。通过合理的线程同步机制和资源管理，可以有效地在Enclave中实现多线程并行处理。

四.感谢支持

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