Container Service for Kubernetes:Use TEE SDK to develop and build Intel SGX 2.0 applications

Prerequisites

Before you begin, make sure you have:

• An ACK managed cluster for confidential computing. See Create an ACK managed cluster for confidential computing

• SSH or Cloud Assistant access to an instance that supports confidential computing

• Git installed, or the ability to install it with sudo yum install git

• Docker installed. See Install and use Docker on a Linux instance

• kubectl configured to connect to your ACK cluster

How it works

An Intel SGX 2.0 application has two components:

• Untrusted component: Unencrypted memory that contains the main() entry function and any OCALL (outside call) implementations. In the diagram, main() and bar() run in the untrusted component.

• Trusted component (enclave): Encrypted memory created and protected by the CPU. Only the CPU can access the code and data inside. In the diagram, helloworld() and foo() run in the enclave.

To call enclave functions from untrusted code, the application uses ECALL (enclave call). To call untrusted functions from inside the enclave, it uses OCALL. Both are declared in Enclave Definition Language (EDL) files.

Sample code and directory structure

The helloworld source code is on GitHub. It includes the application source, Makefile, and Dockerfile.

Top-level structure:

sgx-device-plugin/samples/hello_world/
├── Dockerfile
├── Makefile
├── README.md
└── src
     ├── App
     │ ├── App.cpp
     │ └── App.h
     ├── Enclave
     │ ├── Enclave.config.xml
     │ ├── Enclave.cpp
     │ ├── Enclave.edl
     │ ├── Enclave.h
     │ ├── Enclave.lds
     │ └── Enclave_private.pem
     └── Makefile

The src directory has two subdirectories:

enclave {
 trusted {
 public void ecall_hello_from_enclave([out, size=len] char* buf, size_t len);
 };
};

<EnclaveConfiguration>
    <ProdID>0</ProdID>
    <ISVSVN>0</ISVSVN>
    <StackMaxSize>0x40000</StackMaxSize>
    <HeapMaxSize>0x100000</HeapMaxSize>
    <TCSNum>10</TCSNum>
    <TCSPolicy>1</TCSPolicy>
    <!-- Change 'DisableDebug' to 1 before release to prevent debugger access -->
    <DisableDebug>0</DisableDebug>
    <MiscSelect>0</MiscSelect>
    <MiscMask>0xFFFFFFFF</MiscMask>
</EnclaveConfiguration>

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

Step 1: Compile the hello_world application

1. Install Git:

   sudo yum install git

2. Clone the repository and compile:

   git clone https://github.com/AliyunContainerService/sgx-device-plugin
   cd sgx-device-plugin/samples/hello_world
   SGX_SDK=/opt/alibaba/teesdk/intel/sgxsdk make build

   The build runs six steps:

   1. sgx_edger8r and the sgx_ecall ECALL function generate untrusted stub code (Enclave_u.c, Enclave_u.h) in the App directory.

   2. The untrusted binary files in App are compiled.

   3. sgx_edger8r generates trusted code (Enclave_t.c, Enclave_t.h) in the Enclave directory.

   4. enclave.so is compiled as a trusted dynamic-link library.

   5. sgx_sign signs enclave.so, producing enclave.signed.so.

   6. The final hello_world binary is linked.

   A successful build ends with output similar to:

   GEN  =>  App/Enclave_u.h
   CC   <=  App/Enclave_u.c
   CXX  <=  App/App.cpp
   LINK =>  app
   GEN  =>  Enclave/Enclave_t.h
   CC   <=  Enclave/Enclave_t.c
   CXX  <=  Enclave/Enclave.cpp
   LINK =>  enclave.so
   ...
   tcs_num 10, tcs_max_num 10, tcs_min_pool 1
   The required memory is 3960832B.
   The required memory is 0x3c7000, 3868 KB.
   Succeed.
   SIGN =>  enclave.signed.so
   The project has been built in debug hardware mode

   Verify that the last line reads The project has been built in debug hardware mode. This confirms the build used real SGX hardware (not simulation mode) and that signing completed successfully. The compiled output tree:

   sgx-device-plugin/samples/hello_world/src/
   ├── hello_world          #[generated]
   ├── App
   │ ├── App.cpp
   │ ├── App.h
   │ ├── App.o              #[generated]
   │ ├── Enclave_u.c        #[generated]
   │ ├── Enclave_u.h        #[generated]
   │ └── Enclave_u.o        #[generated]
   ├── Enclave
   │ ├── Enclave.config.xml
   │ ├── Enclave.cpp
   │ ├── Enclave.edl
   │ ├── Enclave.h
   │ ├── Enclave.lds
   │ ├── Enclave.o          #[generated]
   │ ├── Enclave_private.pem
   │ ├── Enclave_t.c        #[generated]
   │ ├── Enclave_t.h        #[generated]
   │ └── Enclave_t.o        #[generated]
   ├── enclave.signed.so    #[generated]
   ├── enclave.so           #[generated]
   └── Makefile

3. Run the application on an SGX-capable instance to verify it works:

   cd src/
   ./hello_world

   Expected output:

   Wed May  6 06:53:33 2020
   Hello world From SGX Enclave!
   Wed May  6 06:53:34 2020
   Hello world From SGX Enclave!
   ...

Step 2: Build and deploy the helloworld application

Use an Alibaba Cloud Linux base image and install the latest SGX SDK. Update the SDK periodically to get security patches.

FROM registry.cn-hangzhou.aliyuncs.com/alinux/alinux3

ARG REGION_ID=cn-hangzhou

RUN yum install -y curl && \
repo_url=https://enclave-${REGION_ID}.oss-${REGION_ID}.aliyuncs.com/repo/alinux/enclave-expr.repo && \
yum install -y yum-utils && \
yum-config-manager --add-repo ${repo_url} && \
yum install -y libsgx-urts libsgx-uae-service # Add more SGX runtime dependencies on demand.

WORKDIR /src
COPY src/hello_world src/enclave.signed.so /src
ENTRYPOINT ["/src/hello_world"]

What's next

• TEE-based confidential computing

• Create an ACK managed cluster for confidential computing

• Intel Software Guard Extensions Developer Guide