diff --git a/rust-sgx-workspace/Cargo.lock b/rust-sgx-workspace/Cargo.lock
index 6049739..c9242b0 100644
--- a/rust-sgx-workspace/Cargo.lock
+++ b/rust-sgx-workspace/Cargo.lock
@@ -755,6 +755,7 @@ dependencies = [
 name = "ntc-tee-server-enclave"
 version = "0.1.0"
 dependencies = [
+ "serde_json",
  "sgx_tstd",
  "sgx_types",
 ]
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/app/Enclave_u.c b/rust-sgx-workspace/projects/ntc-tee-server/app/Enclave_u.c
new file mode 100644
index 0000000..8aa839e
--- /dev/null
+++ b/rust-sgx-workspace/projects/ntc-tee-server/app/Enclave_u.c
@@ -0,0 +1,964 @@
+#include "Enclave_u.h"
+#include <errno.h>
+
+typedef struct ms_append_data_t {
+	sgx_status_t ms_retval;
+	const uint8_t* ms_some_string;
+	size_t ms_len;
+} ms_append_data_t;
+
+typedef struct ms_t_global_init_ecall_t {
+	uint64_t ms_id;
+	const uint8_t* ms_path;
+	size_t ms_len;
+} ms_t_global_init_ecall_t;
+
+typedef struct ms_u_thread_set_event_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const void* ms_tcs;
+} ms_u_thread_set_event_ocall_t;
+
+typedef struct ms_u_thread_wait_event_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const void* ms_tcs;
+	const struct timespec* ms_timeout;
+} ms_u_thread_wait_event_ocall_t;
+
+typedef struct ms_u_thread_set_multiple_events_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const void** ms_tcss;
+	int ms_total;
+} ms_u_thread_set_multiple_events_ocall_t;
+
+typedef struct ms_u_thread_setwait_events_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const void* ms_waiter_tcs;
+	const void* ms_self_tcs;
+	const struct timespec* ms_timeout;
+} ms_u_thread_setwait_events_ocall_t;
+
+typedef struct ms_u_clock_gettime_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_clk_id;
+	struct timespec* ms_tp;
+} ms_u_clock_gettime_ocall_t;
+
+typedef struct ms_u_read_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	void* ms_buf;
+	size_t ms_count;
+} ms_u_read_ocall_t;
+
+typedef struct ms_u_pread64_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	void* ms_buf;
+	size_t ms_count;
+	int64_t ms_offset;
+} ms_u_pread64_ocall_t;
+
+typedef struct ms_u_readv_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	const struct iovec* ms_iov;
+	int ms_iovcnt;
+} ms_u_readv_ocall_t;
+
+typedef struct ms_u_preadv64_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	const struct iovec* ms_iov;
+	int ms_iovcnt;
+	int64_t ms_offset;
+} ms_u_preadv64_ocall_t;
+
+typedef struct ms_u_write_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	const void* ms_buf;
+	size_t ms_count;
+} ms_u_write_ocall_t;
+
+typedef struct ms_u_pwrite64_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	const void* ms_buf;
+	size_t ms_count;
+	int64_t ms_offset;
+} ms_u_pwrite64_ocall_t;
+
+typedef struct ms_u_writev_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	const struct iovec* ms_iov;
+	int ms_iovcnt;
+} ms_u_writev_ocall_t;
+
+typedef struct ms_u_pwritev64_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	const struct iovec* ms_iov;
+	int ms_iovcnt;
+	int64_t ms_offset;
+} ms_u_pwritev64_ocall_t;
+
+typedef struct ms_u_fcntl_arg0_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int ms_cmd;
+} ms_u_fcntl_arg0_ocall_t;
+
+typedef struct ms_u_fcntl_arg1_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int ms_cmd;
+	int ms_arg;
+} ms_u_fcntl_arg1_ocall_t;
+
+typedef struct ms_u_ioctl_arg0_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int ms_request;
+} ms_u_ioctl_arg0_ocall_t;
+
+typedef struct ms_u_ioctl_arg1_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int ms_request;
+	int* ms_arg;
+} ms_u_ioctl_arg1_ocall_t;
+
+typedef struct ms_u_close_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+} ms_u_close_ocall_t;
+
+typedef struct ms_u_malloc_ocall_t {
+	void* ms_retval;
+	int* ms_error;
+	size_t ms_size;
+} ms_u_malloc_ocall_t;
+
+typedef struct ms_u_free_ocall_t {
+	void* ms_p;
+} ms_u_free_ocall_t;
+
+typedef struct ms_u_mmap_ocall_t {
+	void* ms_retval;
+	int* ms_error;
+	void* ms_start;
+	size_t ms_length;
+	int ms_prot;
+	int ms_flags;
+	int ms_fd;
+	int64_t ms_offset;
+} ms_u_mmap_ocall_t;
+
+typedef struct ms_u_munmap_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	void* ms_start;
+	size_t ms_length;
+} ms_u_munmap_ocall_t;
+
+typedef struct ms_u_msync_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	void* ms_addr;
+	size_t ms_length;
+	int ms_flags;
+} ms_u_msync_ocall_t;
+
+typedef struct ms_u_mprotect_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	void* ms_addr;
+	size_t ms_length;
+	int ms_prot;
+} ms_u_mprotect_ocall_t;
+
+typedef struct ms_u_open_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_pathname;
+	int ms_flags;
+} ms_u_open_ocall_t;
+
+typedef struct ms_u_open64_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	int ms_oflag;
+	int ms_mode;
+} ms_u_open64_ocall_t;
+
+typedef struct ms_u_fstat_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	struct stat_t* ms_buf;
+} ms_u_fstat_ocall_t;
+
+typedef struct ms_u_fstat64_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	struct stat64_t* ms_buf;
+} ms_u_fstat64_ocall_t;
+
+typedef struct ms_u_stat_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	struct stat_t* ms_buf;
+} ms_u_stat_ocall_t;
+
+typedef struct ms_u_stat64_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	struct stat64_t* ms_buf;
+} ms_u_stat64_ocall_t;
+
+typedef struct ms_u_lstat_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	struct stat_t* ms_buf;
+} ms_u_lstat_ocall_t;
+
+typedef struct ms_u_lstat64_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	struct stat64_t* ms_buf;
+} ms_u_lstat64_ocall_t;
+
+typedef struct ms_u_lseek_ocall_t {
+	uint64_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int64_t ms_offset;
+	int ms_whence;
+} ms_u_lseek_ocall_t;
+
+typedef struct ms_u_lseek64_ocall_t {
+	int64_t ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int64_t ms_offset;
+	int ms_whence;
+} ms_u_lseek64_ocall_t;
+
+typedef struct ms_u_ftruncate_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int64_t ms_length;
+} ms_u_ftruncate_ocall_t;
+
+typedef struct ms_u_ftruncate64_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	int64_t ms_length;
+} ms_u_ftruncate64_ocall_t;
+
+typedef struct ms_u_truncate_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	int64_t ms_length;
+} ms_u_truncate_ocall_t;
+
+typedef struct ms_u_truncate64_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	int64_t ms_length;
+} ms_u_truncate64_ocall_t;
+
+typedef struct ms_u_fsync_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+} ms_u_fsync_ocall_t;
+
+typedef struct ms_u_fdatasync_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+} ms_u_fdatasync_ocall_t;
+
+typedef struct ms_u_fchmod_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_fd;
+	uint32_t ms_mode;
+} ms_u_fchmod_ocall_t;
+
+typedef struct ms_u_unlink_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_pathname;
+} ms_u_unlink_ocall_t;
+
+typedef struct ms_u_link_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_oldpath;
+	const char* ms_newpath;
+} ms_u_link_ocall_t;
+
+typedef struct ms_u_linkat_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_olddirfd;
+	const char* ms_oldpath;
+	int ms_newdirfd;
+	const char* ms_newpath;
+	int ms_flags;
+} ms_u_linkat_ocall_t;
+
+typedef struct ms_u_rename_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_oldpath;
+	const char* ms_newpath;
+} ms_u_rename_ocall_t;
+
+typedef struct ms_u_chmod_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	uint32_t ms_mode;
+} ms_u_chmod_ocall_t;
+
+typedef struct ms_u_readlink_ocall_t {
+	size_t ms_retval;
+	int* ms_error;
+	const char* ms_path;
+	char* ms_buf;
+	size_t ms_bufsz;
+} ms_u_readlink_ocall_t;
+
+typedef struct ms_u_symlink_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_path1;
+	const char* ms_path2;
+} ms_u_symlink_ocall_t;
+
+typedef struct ms_u_realpath_ocall_t {
+	char* ms_retval;
+	int* ms_error;
+	const char* ms_pathname;
+} ms_u_realpath_ocall_t;
+
+typedef struct ms_u_mkdir_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_pathname;
+	uint32_t ms_mode;
+} ms_u_mkdir_ocall_t;
+
+typedef struct ms_u_rmdir_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	const char* ms_pathname;
+} ms_u_rmdir_ocall_t;
+
+typedef struct ms_u_opendir_ocall_t {
+	void* ms_retval;
+	int* ms_error;
+	const char* ms_pathname;
+} ms_u_opendir_ocall_t;
+
+typedef struct ms_u_readdir64_r_ocall_t {
+	int ms_retval;
+	void* ms_dirp;
+	struct dirent64_t* ms_entry;
+	struct dirent64_t** ms_result;
+} ms_u_readdir64_r_ocall_t;
+
+typedef struct ms_u_closedir_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	void* ms_dirp;
+} ms_u_closedir_ocall_t;
+
+typedef struct ms_u_dirfd_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	void* ms_dirp;
+} ms_u_dirfd_ocall_t;
+
+typedef struct ms_u_fstatat64_ocall_t {
+	int ms_retval;
+	int* ms_error;
+	int ms_dirfd;
+	const char* ms_pathname;
+	struct stat64_t* ms_buf;
+	int ms_flags;
+} ms_u_fstatat64_ocall_t;
+
+static sgx_status_t SGX_CDECL Enclave_u_thread_set_event_ocall(void* pms)
+{
+	ms_u_thread_set_event_ocall_t* ms = SGX_CAST(ms_u_thread_set_event_ocall_t*, pms);
+	ms->ms_retval = u_thread_set_event_ocall(ms->ms_error, ms->ms_tcs);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_thread_wait_event_ocall(void* pms)
+{
+	ms_u_thread_wait_event_ocall_t* ms = SGX_CAST(ms_u_thread_wait_event_ocall_t*, pms);
+	ms->ms_retval = u_thread_wait_event_ocall(ms->ms_error, ms->ms_tcs, ms->ms_timeout);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_thread_set_multiple_events_ocall(void* pms)
+{
+	ms_u_thread_set_multiple_events_ocall_t* ms = SGX_CAST(ms_u_thread_set_multiple_events_ocall_t*, pms);
+	ms->ms_retval = u_thread_set_multiple_events_ocall(ms->ms_error, ms->ms_tcss, ms->ms_total);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_thread_setwait_events_ocall(void* pms)
+{
+	ms_u_thread_setwait_events_ocall_t* ms = SGX_CAST(ms_u_thread_setwait_events_ocall_t*, pms);
+	ms->ms_retval = u_thread_setwait_events_ocall(ms->ms_error, ms->ms_waiter_tcs, ms->ms_self_tcs, ms->ms_timeout);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_clock_gettime_ocall(void* pms)
+{
+	ms_u_clock_gettime_ocall_t* ms = SGX_CAST(ms_u_clock_gettime_ocall_t*, pms);
+	ms->ms_retval = u_clock_gettime_ocall(ms->ms_error, ms->ms_clk_id, ms->ms_tp);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_read_ocall(void* pms)
+{
+	ms_u_read_ocall_t* ms = SGX_CAST(ms_u_read_ocall_t*, pms);
+	ms->ms_retval = u_read_ocall(ms->ms_error, ms->ms_fd, ms->ms_buf, ms->ms_count);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_pread64_ocall(void* pms)
+{
+	ms_u_pread64_ocall_t* ms = SGX_CAST(ms_u_pread64_ocall_t*, pms);
+	ms->ms_retval = u_pread64_ocall(ms->ms_error, ms->ms_fd, ms->ms_buf, ms->ms_count, ms->ms_offset);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_readv_ocall(void* pms)
+{
+	ms_u_readv_ocall_t* ms = SGX_CAST(ms_u_readv_ocall_t*, pms);
+	ms->ms_retval = u_readv_ocall(ms->ms_error, ms->ms_fd, ms->ms_iov, ms->ms_iovcnt);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_preadv64_ocall(void* pms)
+{
+	ms_u_preadv64_ocall_t* ms = SGX_CAST(ms_u_preadv64_ocall_t*, pms);
+	ms->ms_retval = u_preadv64_ocall(ms->ms_error, ms->ms_fd, ms->ms_iov, ms->ms_iovcnt, ms->ms_offset);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_write_ocall(void* pms)
+{
+	ms_u_write_ocall_t* ms = SGX_CAST(ms_u_write_ocall_t*, pms);
+	ms->ms_retval = u_write_ocall(ms->ms_error, ms->ms_fd, ms->ms_buf, ms->ms_count);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_pwrite64_ocall(void* pms)
+{
+	ms_u_pwrite64_ocall_t* ms = SGX_CAST(ms_u_pwrite64_ocall_t*, pms);
+	ms->ms_retval = u_pwrite64_ocall(ms->ms_error, ms->ms_fd, ms->ms_buf, ms->ms_count, ms->ms_offset);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_writev_ocall(void* pms)
+{
+	ms_u_writev_ocall_t* ms = SGX_CAST(ms_u_writev_ocall_t*, pms);
+	ms->ms_retval = u_writev_ocall(ms->ms_error, ms->ms_fd, ms->ms_iov, ms->ms_iovcnt);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_pwritev64_ocall(void* pms)
+{
+	ms_u_pwritev64_ocall_t* ms = SGX_CAST(ms_u_pwritev64_ocall_t*, pms);
+	ms->ms_retval = u_pwritev64_ocall(ms->ms_error, ms->ms_fd, ms->ms_iov, ms->ms_iovcnt, ms->ms_offset);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fcntl_arg0_ocall(void* pms)
+{
+	ms_u_fcntl_arg0_ocall_t* ms = SGX_CAST(ms_u_fcntl_arg0_ocall_t*, pms);
+	ms->ms_retval = u_fcntl_arg0_ocall(ms->ms_error, ms->ms_fd, ms->ms_cmd);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fcntl_arg1_ocall(void* pms)
+{
+	ms_u_fcntl_arg1_ocall_t* ms = SGX_CAST(ms_u_fcntl_arg1_ocall_t*, pms);
+	ms->ms_retval = u_fcntl_arg1_ocall(ms->ms_error, ms->ms_fd, ms->ms_cmd, ms->ms_arg);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_ioctl_arg0_ocall(void* pms)
+{
+	ms_u_ioctl_arg0_ocall_t* ms = SGX_CAST(ms_u_ioctl_arg0_ocall_t*, pms);
+	ms->ms_retval = u_ioctl_arg0_ocall(ms->ms_error, ms->ms_fd, ms->ms_request);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_ioctl_arg1_ocall(void* pms)
+{
+	ms_u_ioctl_arg1_ocall_t* ms = SGX_CAST(ms_u_ioctl_arg1_ocall_t*, pms);
+	ms->ms_retval = u_ioctl_arg1_ocall(ms->ms_error, ms->ms_fd, ms->ms_request, ms->ms_arg);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_close_ocall(void* pms)
+{
+	ms_u_close_ocall_t* ms = SGX_CAST(ms_u_close_ocall_t*, pms);
+	ms->ms_retval = u_close_ocall(ms->ms_error, ms->ms_fd);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_malloc_ocall(void* pms)
+{
+	ms_u_malloc_ocall_t* ms = SGX_CAST(ms_u_malloc_ocall_t*, pms);
+	ms->ms_retval = u_malloc_ocall(ms->ms_error, ms->ms_size);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_free_ocall(void* pms)
+{
+	ms_u_free_ocall_t* ms = SGX_CAST(ms_u_free_ocall_t*, pms);
+	u_free_ocall(ms->ms_p);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_mmap_ocall(void* pms)
+{
+	ms_u_mmap_ocall_t* ms = SGX_CAST(ms_u_mmap_ocall_t*, pms);
+	ms->ms_retval = u_mmap_ocall(ms->ms_error, ms->ms_start, ms->ms_length, ms->ms_prot, ms->ms_flags, ms->ms_fd, ms->ms_offset);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_munmap_ocall(void* pms)
+{
+	ms_u_munmap_ocall_t* ms = SGX_CAST(ms_u_munmap_ocall_t*, pms);
+	ms->ms_retval = u_munmap_ocall(ms->ms_error, ms->ms_start, ms->ms_length);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_msync_ocall(void* pms)
+{
+	ms_u_msync_ocall_t* ms = SGX_CAST(ms_u_msync_ocall_t*, pms);
+	ms->ms_retval = u_msync_ocall(ms->ms_error, ms->ms_addr, ms->ms_length, ms->ms_flags);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_mprotect_ocall(void* pms)
+{
+	ms_u_mprotect_ocall_t* ms = SGX_CAST(ms_u_mprotect_ocall_t*, pms);
+	ms->ms_retval = u_mprotect_ocall(ms->ms_error, ms->ms_addr, ms->ms_length, ms->ms_prot);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_open_ocall(void* pms)
+{
+	ms_u_open_ocall_t* ms = SGX_CAST(ms_u_open_ocall_t*, pms);
+	ms->ms_retval = u_open_ocall(ms->ms_error, ms->ms_pathname, ms->ms_flags);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_open64_ocall(void* pms)
+{
+	ms_u_open64_ocall_t* ms = SGX_CAST(ms_u_open64_ocall_t*, pms);
+	ms->ms_retval = u_open64_ocall(ms->ms_error, ms->ms_path, ms->ms_oflag, ms->ms_mode);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fstat_ocall(void* pms)
+{
+	ms_u_fstat_ocall_t* ms = SGX_CAST(ms_u_fstat_ocall_t*, pms);
+	ms->ms_retval = u_fstat_ocall(ms->ms_error, ms->ms_fd, ms->ms_buf);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fstat64_ocall(void* pms)
+{
+	ms_u_fstat64_ocall_t* ms = SGX_CAST(ms_u_fstat64_ocall_t*, pms);
+	ms->ms_retval = u_fstat64_ocall(ms->ms_error, ms->ms_fd, ms->ms_buf);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_stat_ocall(void* pms)
+{
+	ms_u_stat_ocall_t* ms = SGX_CAST(ms_u_stat_ocall_t*, pms);
+	ms->ms_retval = u_stat_ocall(ms->ms_error, ms->ms_path, ms->ms_buf);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_stat64_ocall(void* pms)
+{
+	ms_u_stat64_ocall_t* ms = SGX_CAST(ms_u_stat64_ocall_t*, pms);
+	ms->ms_retval = u_stat64_ocall(ms->ms_error, ms->ms_path, ms->ms_buf);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_lstat_ocall(void* pms)
+{
+	ms_u_lstat_ocall_t* ms = SGX_CAST(ms_u_lstat_ocall_t*, pms);
+	ms->ms_retval = u_lstat_ocall(ms->ms_error, ms->ms_path, ms->ms_buf);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_lstat64_ocall(void* pms)
+{
+	ms_u_lstat64_ocall_t* ms = SGX_CAST(ms_u_lstat64_ocall_t*, pms);
+	ms->ms_retval = u_lstat64_ocall(ms->ms_error, ms->ms_path, ms->ms_buf);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_lseek_ocall(void* pms)
+{
+	ms_u_lseek_ocall_t* ms = SGX_CAST(ms_u_lseek_ocall_t*, pms);
+	ms->ms_retval = u_lseek_ocall(ms->ms_error, ms->ms_fd, ms->ms_offset, ms->ms_whence);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_lseek64_ocall(void* pms)
+{
+	ms_u_lseek64_ocall_t* ms = SGX_CAST(ms_u_lseek64_ocall_t*, pms);
+	ms->ms_retval = u_lseek64_ocall(ms->ms_error, ms->ms_fd, ms->ms_offset, ms->ms_whence);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_ftruncate_ocall(void* pms)
+{
+	ms_u_ftruncate_ocall_t* ms = SGX_CAST(ms_u_ftruncate_ocall_t*, pms);
+	ms->ms_retval = u_ftruncate_ocall(ms->ms_error, ms->ms_fd, ms->ms_length);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_ftruncate64_ocall(void* pms)
+{
+	ms_u_ftruncate64_ocall_t* ms = SGX_CAST(ms_u_ftruncate64_ocall_t*, pms);
+	ms->ms_retval = u_ftruncate64_ocall(ms->ms_error, ms->ms_fd, ms->ms_length);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_truncate_ocall(void* pms)
+{
+	ms_u_truncate_ocall_t* ms = SGX_CAST(ms_u_truncate_ocall_t*, pms);
+	ms->ms_retval = u_truncate_ocall(ms->ms_error, ms->ms_path, ms->ms_length);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_truncate64_ocall(void* pms)
+{
+	ms_u_truncate64_ocall_t* ms = SGX_CAST(ms_u_truncate64_ocall_t*, pms);
+	ms->ms_retval = u_truncate64_ocall(ms->ms_error, ms->ms_path, ms->ms_length);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fsync_ocall(void* pms)
+{
+	ms_u_fsync_ocall_t* ms = SGX_CAST(ms_u_fsync_ocall_t*, pms);
+	ms->ms_retval = u_fsync_ocall(ms->ms_error, ms->ms_fd);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fdatasync_ocall(void* pms)
+{
+	ms_u_fdatasync_ocall_t* ms = SGX_CAST(ms_u_fdatasync_ocall_t*, pms);
+	ms->ms_retval = u_fdatasync_ocall(ms->ms_error, ms->ms_fd);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fchmod_ocall(void* pms)
+{
+	ms_u_fchmod_ocall_t* ms = SGX_CAST(ms_u_fchmod_ocall_t*, pms);
+	ms->ms_retval = u_fchmod_ocall(ms->ms_error, ms->ms_fd, ms->ms_mode);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_unlink_ocall(void* pms)
+{
+	ms_u_unlink_ocall_t* ms = SGX_CAST(ms_u_unlink_ocall_t*, pms);
+	ms->ms_retval = u_unlink_ocall(ms->ms_error, ms->ms_pathname);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_link_ocall(void* pms)
+{
+	ms_u_link_ocall_t* ms = SGX_CAST(ms_u_link_ocall_t*, pms);
+	ms->ms_retval = u_link_ocall(ms->ms_error, ms->ms_oldpath, ms->ms_newpath);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_linkat_ocall(void* pms)
+{
+	ms_u_linkat_ocall_t* ms = SGX_CAST(ms_u_linkat_ocall_t*, pms);
+	ms->ms_retval = u_linkat_ocall(ms->ms_error, ms->ms_olddirfd, ms->ms_oldpath, ms->ms_newdirfd, ms->ms_newpath, ms->ms_flags);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_rename_ocall(void* pms)
+{
+	ms_u_rename_ocall_t* ms = SGX_CAST(ms_u_rename_ocall_t*, pms);
+	ms->ms_retval = u_rename_ocall(ms->ms_error, ms->ms_oldpath, ms->ms_newpath);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_chmod_ocall(void* pms)
+{
+	ms_u_chmod_ocall_t* ms = SGX_CAST(ms_u_chmod_ocall_t*, pms);
+	ms->ms_retval = u_chmod_ocall(ms->ms_error, ms->ms_path, ms->ms_mode);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_readlink_ocall(void* pms)
+{
+	ms_u_readlink_ocall_t* ms = SGX_CAST(ms_u_readlink_ocall_t*, pms);
+	ms->ms_retval = u_readlink_ocall(ms->ms_error, ms->ms_path, ms->ms_buf, ms->ms_bufsz);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_symlink_ocall(void* pms)
+{
+	ms_u_symlink_ocall_t* ms = SGX_CAST(ms_u_symlink_ocall_t*, pms);
+	ms->ms_retval = u_symlink_ocall(ms->ms_error, ms->ms_path1, ms->ms_path2);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_realpath_ocall(void* pms)
+{
+	ms_u_realpath_ocall_t* ms = SGX_CAST(ms_u_realpath_ocall_t*, pms);
+	ms->ms_retval = u_realpath_ocall(ms->ms_error, ms->ms_pathname);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_mkdir_ocall(void* pms)
+{
+	ms_u_mkdir_ocall_t* ms = SGX_CAST(ms_u_mkdir_ocall_t*, pms);
+	ms->ms_retval = u_mkdir_ocall(ms->ms_error, ms->ms_pathname, ms->ms_mode);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_rmdir_ocall(void* pms)
+{
+	ms_u_rmdir_ocall_t* ms = SGX_CAST(ms_u_rmdir_ocall_t*, pms);
+	ms->ms_retval = u_rmdir_ocall(ms->ms_error, ms->ms_pathname);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_opendir_ocall(void* pms)
+{
+	ms_u_opendir_ocall_t* ms = SGX_CAST(ms_u_opendir_ocall_t*, pms);
+	ms->ms_retval = u_opendir_ocall(ms->ms_error, ms->ms_pathname);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_readdir64_r_ocall(void* pms)
+{
+	ms_u_readdir64_r_ocall_t* ms = SGX_CAST(ms_u_readdir64_r_ocall_t*, pms);
+	ms->ms_retval = u_readdir64_r_ocall(ms->ms_dirp, ms->ms_entry, ms->ms_result);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_closedir_ocall(void* pms)
+{
+	ms_u_closedir_ocall_t* ms = SGX_CAST(ms_u_closedir_ocall_t*, pms);
+	ms->ms_retval = u_closedir_ocall(ms->ms_error, ms->ms_dirp);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_dirfd_ocall(void* pms)
+{
+	ms_u_dirfd_ocall_t* ms = SGX_CAST(ms_u_dirfd_ocall_t*, pms);
+	ms->ms_retval = u_dirfd_ocall(ms->ms_error, ms->ms_dirp);
+
+	return SGX_SUCCESS;
+}
+
+static sgx_status_t SGX_CDECL Enclave_u_fstatat64_ocall(void* pms)
+{
+	ms_u_fstatat64_ocall_t* ms = SGX_CAST(ms_u_fstatat64_ocall_t*, pms);
+	ms->ms_retval = u_fstatat64_ocall(ms->ms_error, ms->ms_dirfd, ms->ms_pathname, ms->ms_buf, ms->ms_flags);
+
+	return SGX_SUCCESS;
+}
+
+static const struct {
+	size_t nr_ocall;
+	void * table[56];
+} ocall_table_Enclave = {
+	56,
+	{
+		(void*)Enclave_u_thread_set_event_ocall,
+		(void*)Enclave_u_thread_wait_event_ocall,
+		(void*)Enclave_u_thread_set_multiple_events_ocall,
+		(void*)Enclave_u_thread_setwait_events_ocall,
+		(void*)Enclave_u_clock_gettime_ocall,
+		(void*)Enclave_u_read_ocall,
+		(void*)Enclave_u_pread64_ocall,
+		(void*)Enclave_u_readv_ocall,
+		(void*)Enclave_u_preadv64_ocall,
+		(void*)Enclave_u_write_ocall,
+		(void*)Enclave_u_pwrite64_ocall,
+		(void*)Enclave_u_writev_ocall,
+		(void*)Enclave_u_pwritev64_ocall,
+		(void*)Enclave_u_fcntl_arg0_ocall,
+		(void*)Enclave_u_fcntl_arg1_ocall,
+		(void*)Enclave_u_ioctl_arg0_ocall,
+		(void*)Enclave_u_ioctl_arg1_ocall,
+		(void*)Enclave_u_close_ocall,
+		(void*)Enclave_u_malloc_ocall,
+		(void*)Enclave_u_free_ocall,
+		(void*)Enclave_u_mmap_ocall,
+		(void*)Enclave_u_munmap_ocall,
+		(void*)Enclave_u_msync_ocall,
+		(void*)Enclave_u_mprotect_ocall,
+		(void*)Enclave_u_open_ocall,
+		(void*)Enclave_u_open64_ocall,
+		(void*)Enclave_u_fstat_ocall,
+		(void*)Enclave_u_fstat64_ocall,
+		(void*)Enclave_u_stat_ocall,
+		(void*)Enclave_u_stat64_ocall,
+		(void*)Enclave_u_lstat_ocall,
+		(void*)Enclave_u_lstat64_ocall,
+		(void*)Enclave_u_lseek_ocall,
+		(void*)Enclave_u_lseek64_ocall,
+		(void*)Enclave_u_ftruncate_ocall,
+		(void*)Enclave_u_ftruncate64_ocall,
+		(void*)Enclave_u_truncate_ocall,
+		(void*)Enclave_u_truncate64_ocall,
+		(void*)Enclave_u_fsync_ocall,
+		(void*)Enclave_u_fdatasync_ocall,
+		(void*)Enclave_u_fchmod_ocall,
+		(void*)Enclave_u_unlink_ocall,
+		(void*)Enclave_u_link_ocall,
+		(void*)Enclave_u_linkat_ocall,
+		(void*)Enclave_u_rename_ocall,
+		(void*)Enclave_u_chmod_ocall,
+		(void*)Enclave_u_readlink_ocall,
+		(void*)Enclave_u_symlink_ocall,
+		(void*)Enclave_u_realpath_ocall,
+		(void*)Enclave_u_mkdir_ocall,
+		(void*)Enclave_u_rmdir_ocall,
+		(void*)Enclave_u_opendir_ocall,
+		(void*)Enclave_u_readdir64_r_ocall,
+		(void*)Enclave_u_closedir_ocall,
+		(void*)Enclave_u_dirfd_ocall,
+		(void*)Enclave_u_fstatat64_ocall,
+	}
+};
+sgx_status_t append_data(sgx_enclave_id_t eid, sgx_status_t* retval, const uint8_t* some_string, size_t len)
+{
+	sgx_status_t status;
+	ms_append_data_t ms;
+	ms.ms_some_string = some_string;
+	ms.ms_len = len;
+	status = sgx_ecall(eid, 0, &ocall_table_Enclave, &ms);
+	if (status == SGX_SUCCESS && retval) *retval = ms.ms_retval;
+	return status;
+}
+
+sgx_status_t t_global_init_ecall(sgx_enclave_id_t eid, uint64_t id, const uint8_t* path, size_t len)
+{
+	sgx_status_t status;
+	ms_t_global_init_ecall_t ms;
+	ms.ms_id = id;
+	ms.ms_path = path;
+	ms.ms_len = len;
+	status = sgx_ecall(eid, 1, &ocall_table_Enclave, &ms);
+	return status;
+}
+
+sgx_status_t t_global_exit_ecall(sgx_enclave_id_t eid)
+{
+	sgx_status_t status;
+	status = sgx_ecall(eid, 2, &ocall_table_Enclave, NULL);
+	return status;
+}
+
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/app/Enclave_u.h b/rust-sgx-workspace/projects/ntc-tee-server/app/Enclave_u.h
new file mode 100644
index 0000000..d2ec9fa
--- /dev/null
+++ b/rust-sgx-workspace/projects/ntc-tee-server/app/Enclave_u.h
@@ -0,0 +1,257 @@
+#ifndef ENCLAVE_U_H__
+#define ENCLAVE_U_H__
+
+#include <stdint.h>
+#include <wchar.h>
+#include <stddef.h>
+#include <string.h>
+#include "sgx_edger8r.h" /* for sgx_status_t etc. */
+
+#include "time.h"
+#include "inc/stat.h"
+#include "sys/uio.h"
+#include "inc/stat.h"
+#include "inc/dirent.h"
+
+#include <stdlib.h> /* for size_t */
+
+#define SGX_CAST(type, item) ((type)(item))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef U_THREAD_SET_EVENT_OCALL_DEFINED__
+#define U_THREAD_SET_EVENT_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_thread_set_event_ocall, (int* error, const void* tcs));
+#endif
+#ifndef U_THREAD_WAIT_EVENT_OCALL_DEFINED__
+#define U_THREAD_WAIT_EVENT_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_thread_wait_event_ocall, (int* error, const void* tcs, const struct timespec* timeout));
+#endif
+#ifndef U_THREAD_SET_MULTIPLE_EVENTS_OCALL_DEFINED__
+#define U_THREAD_SET_MULTIPLE_EVENTS_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_thread_set_multiple_events_ocall, (int* error, const void** tcss, int total));
+#endif
+#ifndef U_THREAD_SETWAIT_EVENTS_OCALL_DEFINED__
+#define U_THREAD_SETWAIT_EVENTS_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_thread_setwait_events_ocall, (int* error, const void* waiter_tcs, const void* self_tcs, const struct timespec* timeout));
+#endif
+#ifndef U_CLOCK_GETTIME_OCALL_DEFINED__
+#define U_CLOCK_GETTIME_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_clock_gettime_ocall, (int* error, int clk_id, struct timespec* tp));
+#endif
+#ifndef U_READ_OCALL_DEFINED__
+#define U_READ_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_read_ocall, (int* error, int fd, void* buf, size_t count));
+#endif
+#ifndef U_PREAD64_OCALL_DEFINED__
+#define U_PREAD64_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_pread64_ocall, (int* error, int fd, void* buf, size_t count, int64_t offset));
+#endif
+#ifndef U_READV_OCALL_DEFINED__
+#define U_READV_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_readv_ocall, (int* error, int fd, const struct iovec* iov, int iovcnt));
+#endif
+#ifndef U_PREADV64_OCALL_DEFINED__
+#define U_PREADV64_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_preadv64_ocall, (int* error, int fd, const struct iovec* iov, int iovcnt, int64_t offset));
+#endif
+#ifndef U_WRITE_OCALL_DEFINED__
+#define U_WRITE_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_write_ocall, (int* error, int fd, const void* buf, size_t count));
+#endif
+#ifndef U_PWRITE64_OCALL_DEFINED__
+#define U_PWRITE64_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_pwrite64_ocall, (int* error, int fd, const void* buf, size_t count, int64_t offset));
+#endif
+#ifndef U_WRITEV_OCALL_DEFINED__
+#define U_WRITEV_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_writev_ocall, (int* error, int fd, const struct iovec* iov, int iovcnt));
+#endif
+#ifndef U_PWRITEV64_OCALL_DEFINED__
+#define U_PWRITEV64_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_pwritev64_ocall, (int* error, int fd, const struct iovec* iov, int iovcnt, int64_t offset));
+#endif
+#ifndef U_FCNTL_ARG0_OCALL_DEFINED__
+#define U_FCNTL_ARG0_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fcntl_arg0_ocall, (int* error, int fd, int cmd));
+#endif
+#ifndef U_FCNTL_ARG1_OCALL_DEFINED__
+#define U_FCNTL_ARG1_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fcntl_arg1_ocall, (int* error, int fd, int cmd, int arg));
+#endif
+#ifndef U_IOCTL_ARG0_OCALL_DEFINED__
+#define U_IOCTL_ARG0_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_ioctl_arg0_ocall, (int* error, int fd, int request));
+#endif
+#ifndef U_IOCTL_ARG1_OCALL_DEFINED__
+#define U_IOCTL_ARG1_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_ioctl_arg1_ocall, (int* error, int fd, int request, int* arg));
+#endif
+#ifndef U_CLOSE_OCALL_DEFINED__
+#define U_CLOSE_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_close_ocall, (int* error, int fd));
+#endif
+#ifndef U_MALLOC_OCALL_DEFINED__
+#define U_MALLOC_OCALL_DEFINED__
+void* SGX_UBRIDGE(SGX_NOCONVENTION, u_malloc_ocall, (int* error, size_t size));
+#endif
+#ifndef U_FREE_OCALL_DEFINED__
+#define U_FREE_OCALL_DEFINED__
+void SGX_UBRIDGE(SGX_NOCONVENTION, u_free_ocall, (void* p));
+#endif
+#ifndef U_MMAP_OCALL_DEFINED__
+#define U_MMAP_OCALL_DEFINED__
+void* SGX_UBRIDGE(SGX_NOCONVENTION, u_mmap_ocall, (int* error, void* start, size_t length, int prot, int flags, int fd, int64_t offset));
+#endif
+#ifndef U_MUNMAP_OCALL_DEFINED__
+#define U_MUNMAP_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_munmap_ocall, (int* error, void* start, size_t length));
+#endif
+#ifndef U_MSYNC_OCALL_DEFINED__
+#define U_MSYNC_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_msync_ocall, (int* error, void* addr, size_t length, int flags));
+#endif
+#ifndef U_MPROTECT_OCALL_DEFINED__
+#define U_MPROTECT_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_mprotect_ocall, (int* error, void* addr, size_t length, int prot));
+#endif
+#ifndef U_OPEN_OCALL_DEFINED__
+#define U_OPEN_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_open_ocall, (int* error, const char* pathname, int flags));
+#endif
+#ifndef U_OPEN64_OCALL_DEFINED__
+#define U_OPEN64_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_open64_ocall, (int* error, const char* path, int oflag, int mode));
+#endif
+#ifndef U_FSTAT_OCALL_DEFINED__
+#define U_FSTAT_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fstat_ocall, (int* error, int fd, struct stat_t* buf));
+#endif
+#ifndef U_FSTAT64_OCALL_DEFINED__
+#define U_FSTAT64_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fstat64_ocall, (int* error, int fd, struct stat64_t* buf));
+#endif
+#ifndef U_STAT_OCALL_DEFINED__
+#define U_STAT_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_stat_ocall, (int* error, const char* path, struct stat_t* buf));
+#endif
+#ifndef U_STAT64_OCALL_DEFINED__
+#define U_STAT64_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_stat64_ocall, (int* error, const char* path, struct stat64_t* buf));
+#endif
+#ifndef U_LSTAT_OCALL_DEFINED__
+#define U_LSTAT_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_lstat_ocall, (int* error, const char* path, struct stat_t* buf));
+#endif
+#ifndef U_LSTAT64_OCALL_DEFINED__
+#define U_LSTAT64_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_lstat64_ocall, (int* error, const char* path, struct stat64_t* buf));
+#endif
+#ifndef U_LSEEK_OCALL_DEFINED__
+#define U_LSEEK_OCALL_DEFINED__
+uint64_t SGX_UBRIDGE(SGX_NOCONVENTION, u_lseek_ocall, (int* error, int fd, int64_t offset, int whence));
+#endif
+#ifndef U_LSEEK64_OCALL_DEFINED__
+#define U_LSEEK64_OCALL_DEFINED__
+int64_t SGX_UBRIDGE(SGX_NOCONVENTION, u_lseek64_ocall, (int* error, int fd, int64_t offset, int whence));
+#endif
+#ifndef U_FTRUNCATE_OCALL_DEFINED__
+#define U_FTRUNCATE_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_ftruncate_ocall, (int* error, int fd, int64_t length));
+#endif
+#ifndef U_FTRUNCATE64_OCALL_DEFINED__
+#define U_FTRUNCATE64_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_ftruncate64_ocall, (int* error, int fd, int64_t length));
+#endif
+#ifndef U_TRUNCATE_OCALL_DEFINED__
+#define U_TRUNCATE_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_truncate_ocall, (int* error, const char* path, int64_t length));
+#endif
+#ifndef U_TRUNCATE64_OCALL_DEFINED__
+#define U_TRUNCATE64_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_truncate64_ocall, (int* error, const char* path, int64_t length));
+#endif
+#ifndef U_FSYNC_OCALL_DEFINED__
+#define U_FSYNC_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fsync_ocall, (int* error, int fd));
+#endif
+#ifndef U_FDATASYNC_OCALL_DEFINED__
+#define U_FDATASYNC_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fdatasync_ocall, (int* error, int fd));
+#endif
+#ifndef U_FCHMOD_OCALL_DEFINED__
+#define U_FCHMOD_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fchmod_ocall, (int* error, int fd, uint32_t mode));
+#endif
+#ifndef U_UNLINK_OCALL_DEFINED__
+#define U_UNLINK_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_unlink_ocall, (int* error, const char* pathname));
+#endif
+#ifndef U_LINK_OCALL_DEFINED__
+#define U_LINK_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_link_ocall, (int* error, const char* oldpath, const char* newpath));
+#endif
+#ifndef U_LINKAT_OCALL_DEFINED__
+#define U_LINKAT_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_linkat_ocall, (int* error, int olddirfd, const char* oldpath, int newdirfd, const char* newpath, int flags));
+#endif
+#ifndef U_RENAME_OCALL_DEFINED__
+#define U_RENAME_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_rename_ocall, (int* error, const char* oldpath, const char* newpath));
+#endif
+#ifndef U_CHMOD_OCALL_DEFINED__
+#define U_CHMOD_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_chmod_ocall, (int* error, const char* path, uint32_t mode));
+#endif
+#ifndef U_READLINK_OCALL_DEFINED__
+#define U_READLINK_OCALL_DEFINED__
+size_t SGX_UBRIDGE(SGX_NOCONVENTION, u_readlink_ocall, (int* error, const char* path, char* buf, size_t bufsz));
+#endif
+#ifndef U_SYMLINK_OCALL_DEFINED__
+#define U_SYMLINK_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_symlink_ocall, (int* error, const char* path1, const char* path2));
+#endif
+#ifndef U_REALPATH_OCALL_DEFINED__
+#define U_REALPATH_OCALL_DEFINED__
+char* SGX_UBRIDGE(SGX_NOCONVENTION, u_realpath_ocall, (int* error, const char* pathname));
+#endif
+#ifndef U_MKDIR_OCALL_DEFINED__
+#define U_MKDIR_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_mkdir_ocall, (int* error, const char* pathname, uint32_t mode));
+#endif
+#ifndef U_RMDIR_OCALL_DEFINED__
+#define U_RMDIR_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_rmdir_ocall, (int* error, const char* pathname));
+#endif
+#ifndef U_OPENDIR_OCALL_DEFINED__
+#define U_OPENDIR_OCALL_DEFINED__
+void* SGX_UBRIDGE(SGX_NOCONVENTION, u_opendir_ocall, (int* error, const char* pathname));
+#endif
+#ifndef U_READDIR64_R_OCALL_DEFINED__
+#define U_READDIR64_R_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_readdir64_r_ocall, (void* dirp, struct dirent64_t* entry, struct dirent64_t** result));
+#endif
+#ifndef U_CLOSEDIR_OCALL_DEFINED__
+#define U_CLOSEDIR_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_closedir_ocall, (int* error, void* dirp));
+#endif
+#ifndef U_DIRFD_OCALL_DEFINED__
+#define U_DIRFD_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_dirfd_ocall, (int* error, void* dirp));
+#endif
+#ifndef U_FSTATAT64_OCALL_DEFINED__
+#define U_FSTATAT64_OCALL_DEFINED__
+int SGX_UBRIDGE(SGX_NOCONVENTION, u_fstatat64_ocall, (int* error, int dirfd, const char* pathname, struct stat64_t* buf, int flags));
+#endif
+
+sgx_status_t append_data(sgx_enclave_id_t eid, sgx_status_t* retval, const uint8_t* some_string, size_t len);
+sgx_status_t t_global_init_ecall(sgx_enclave_id_t eid, uint64_t id, const uint8_t* path, size_t len);
+sgx_status_t t_global_exit_ecall(sgx_enclave_id_t eid);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/app/Makefile b/rust-sgx-workspace/projects/ntc-tee-server/app/Makefile
index 39763ec..4746308 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/app/Makefile
+++ b/rust-sgx-workspace/projects/ntc-tee-server/app/Makefile
@@ -72,7 +72,7 @@ $(CODEGEN_U)Enclave_u.rs: $(CODEGEN_U)Enclave_u.h
 	@bindgen \
 		--no-recursive-allowlist \
 		--raw-line 'use sgx_types::*;' \
-		--allowlist-function ecall_test \
+		--allowlist-function append_data \
 		--output $@ \
 		$? \
 		-- -I$(SGX_SDK)/include -I$(CUSTOM_EDL_PATH)
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.c b/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.c
index c4b408c..8aa839e 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.c
+++ b/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.c
@@ -1,11 +1,11 @@
 #include "Enclave_u.h"
 #include <errno.h>
 
-typedef struct ms_ecall_test_t {
+typedef struct ms_append_data_t {
 	sgx_status_t ms_retval;
 	const uint8_t* ms_some_string;
 	size_t ms_len;
-} ms_ecall_test_t;
+} ms_append_data_t;
 
 typedef struct ms_t_global_init_ecall_t {
 	uint64_t ms_id;
@@ -933,10 +933,10 @@ static const struct {
 		(void*)Enclave_u_fstatat64_ocall,
 	}
 };
-sgx_status_t ecall_test(sgx_enclave_id_t eid, sgx_status_t* retval, const uint8_t* some_string, size_t len)
+sgx_status_t append_data(sgx_enclave_id_t eid, sgx_status_t* retval, const uint8_t* some_string, size_t len)
 {
 	sgx_status_t status;
-	ms_ecall_test_t ms;
+	ms_append_data_t ms;
 	ms.ms_some_string = some_string;
 	ms.ms_len = len;
 	status = sgx_ecall(eid, 0, &ocall_table_Enclave, &ms);
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.h b/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.h
index 701aeb0..d2ec9fa 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.h
+++ b/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.h
@@ -246,7 +246,7 @@ int SGX_UBRIDGE(SGX_NOCONVENTION, u_dirfd_ocall, (int* error, void* dirp));
 int SGX_UBRIDGE(SGX_NOCONVENTION, u_fstatat64_ocall, (int* error, int dirfd, const char* pathname, struct stat64_t* buf, int flags));
 #endif
 
-sgx_status_t ecall_test(sgx_enclave_id_t eid, sgx_status_t* retval, const uint8_t* some_string, size_t len);
+sgx_status_t append_data(sgx_enclave_id_t eid, sgx_status_t* retval, const uint8_t* some_string, size_t len);
 sgx_status_t t_global_init_ecall(sgx_enclave_id_t eid, uint64_t id, const uint8_t* path, size_t len);
 sgx_status_t t_global_exit_ecall(sgx_enclave_id_t eid);
 
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.rs b/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.rs
index fdf8412..6397a3b 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.rs
+++ b/rust-sgx-workspace/projects/ntc-tee-server/app/codegen/Enclave_u.rs
@@ -1,9 +1,9 @@
-/* automatically generated by rust-bindgen 0.59.2 */
+/* automatically generated by rust-bindgen 0.60.1 */
 
 use sgx_types::*;
 
 extern "C" {
-    pub fn ecall_test(
+    pub fn append_data(
         eid: sgx_enclave_id_t,
         retval: *mut sgx_status_t,
         some_string: *const u8,
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/app/src/main.rs b/rust-sgx-workspace/projects/ntc-tee-server/app/src/main.rs
index 1b3d152..5af2f31 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/app/src/main.rs
+++ b/rust-sgx-workspace/projects/ntc-tee-server/app/src/main.rs
@@ -1,21 +1,23 @@
 extern crate sgx_types;
 extern crate sgx_urts;
-
-#[path = "../codegen/Enclave_u.rs"]
-mod enclave_u;
-
-use enclave_u::ecall_test;
-use sgx_types::{
-    sgx_attributes_t,
-    sgx_launch_token_t,
-    sgx_misc_attribute_t,
-    sgx_status_t,
-    SgxResult,
-};
+use sgx_types::*;
 use sgx_urts::SgxEnclave;
 
 static ENCLAVE_FILE: &str = "enclave.signed.so";
 
+extern "C" {
+
+    // Update function to ecall two (sealed) data pools from CosmosDB
+    // Use Data API in nautilus-trusted-compute/rust-workspace/projects/data-server/src/data_handlers
+    fn append_data(
+        eid: sgx_enclave_id_t,
+        retval: *mut sgx_status_t,
+        input_string: *const u8,
+        input_length: usize,
+    ) -> sgx_status_t;
+
+}
+
 fn init_enclave() -> SgxResult<SgxEnclave> {
     let mut launch_token: sgx_launch_token_t = [0; 1024];
     let mut launch_token_updated: i32 = 0;
@@ -47,12 +49,13 @@ fn main() {
         }
     };
 
+    // Update - send sealed binary data into enclave (from CosmosDB)
     let input_string = String::from("Sending this string to the enclave then printing it\n");
 
     let mut retval = sgx_status_t::SGX_SUCCESS;
 
     let result = unsafe {
-        ecall_test(
+        append_data(
             enclave.geteid(),
             &mut retval,
             input_string.as_ptr() as *const u8,
@@ -61,14 +64,14 @@ fn main() {
     };
 
     match result {
-        sgx_status_t::SGX_SUCCESS => {}
+        sgx_status_t::SGX_SUCCESS => {
+            println!("[+] Ecall success...");
+        }
         _ => {
             println!("[-] ECALL Enclave Failed {}!", result.as_str());
             return;
         }
     }
 
-    println!("[+] ecall_test success...");
-
     enclave.destroy();
 }
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/enclave/Cargo.toml b/rust-sgx-workspace/projects/ntc-tee-server/enclave/Cargo.toml
index 0d3a345..a88ba07 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/enclave/Cargo.toml
+++ b/rust-sgx-workspace/projects/ntc-tee-server/enclave/Cargo.toml
@@ -12,5 +12,12 @@ test = false
 default = []
 
 [dependencies]
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
+
+[target.'cfg(not(target_env = "sgx"))'.dependencies] # You can remove what you don't need, except types and tstd
 sgx_types = { git = "https://github.com/apache/incubator-teaclave-sgx-sdk", rev = "e8a9fc22939befa27ff67f5509b2c2dfe8499945" }
-sgx_tstd = { git = "https://github.com/apache/incubator-teaclave-sgx-sdk", features = ["backtrace"], rev = "e8a9fc22939befa27ff67f5509b2c2dfe8499945" }
+sgx_tstd = { git = "https://github.com/apache/incubator-teaclave-sgx-sdk", features = [
+  "backtrace",
+], rev = "e8a9fc22939befa27ff67f5509b2c2dfe8499945" }
+
+[patch.'https://github.com/apache/teaclave-sgx-sdk.git']
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/enclave/Enclave.edl b/rust-sgx-workspace/projects/ntc-tee-server/enclave/Enclave.edl
index 740d877..a7d8308 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/enclave/Enclave.edl
+++ b/rust-sgx-workspace/projects/ntc-tee-server/enclave/Enclave.edl
@@ -3,7 +3,7 @@ enclave {
     from "sgx_backtrace.edl" import *;
     trusted
     {
-        public sgx_status_t ecall_test([in, size=len] const uint8_t* some_string, size_t len);
+        public sgx_status_t append_data([in, size=len] const uint8_t* some_string, size_t len);
     };
     untrusted
     {
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.c b/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.c
index 04ac8fb..f51b00d 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.c
+++ b/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.c
@@ -27,11 +27,11 @@
 )
 
 
-typedef struct ms_ecall_test_t {
+typedef struct ms_append_data_t {
 	sgx_status_t ms_retval;
 	const uint8_t* ms_some_string;
 	size_t ms_len;
-} ms_ecall_test_t;
+} ms_append_data_t;
 
 typedef struct ms_t_global_init_ecall_t {
 	uint64_t ms_id;
@@ -447,14 +447,14 @@ typedef struct ms_u_fstatat64_ocall_t {
 	int ms_flags;
 } ms_u_fstatat64_ocall_t;
 
-static sgx_status_t SGX_CDECL sgx_ecall_test(void* pms)
+static sgx_status_t SGX_CDECL sgx_append_data(void* pms)
 {
-	CHECK_REF_POINTER(pms, sizeof(ms_ecall_test_t));
+	CHECK_REF_POINTER(pms, sizeof(ms_append_data_t));
 	//
 	// fence after pointer checks
 	//
 	sgx_lfence();
-	ms_ecall_test_t* ms = SGX_CAST(ms_ecall_test_t*, pms);
+	ms_append_data_t* ms = SGX_CAST(ms_append_data_t*, pms);
 	sgx_status_t status = SGX_SUCCESS;
 	const uint8_t* _tmp_some_string = ms->ms_some_string;
 	size_t _tmp_len = ms->ms_len;
@@ -487,7 +487,7 @@ static sgx_status_t SGX_CDECL sgx_ecall_test(void* pms)
 
 	}
 
-	ms->ms_retval = ecall_test((const uint8_t*)_in_some_string, _tmp_len);
+	ms->ms_retval = append_data((const uint8_t*)_in_some_string, _tmp_len);
 
 err:
 	if (_in_some_string) free(_in_some_string);
@@ -555,7 +555,7 @@ SGX_EXTERNC const struct {
 } g_ecall_table = {
 	3,
 	{
-		{(void*)(uintptr_t)sgx_ecall_test, 0, 0},
+		{(void*)(uintptr_t)sgx_append_data, 0, 0},
 		{(void*)(uintptr_t)sgx_t_global_init_ecall, 0, 0},
 		{(void*)(uintptr_t)sgx_t_global_exit_ecall, 0, 0},
 	}
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.h b/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.h
index 5c5a7db..9d5d35c 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.h
+++ b/rust-sgx-workspace/projects/ntc-tee-server/enclave/codegen/Enclave_t.h
@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-sgx_status_t ecall_test(const uint8_t* some_string, size_t len);
+sgx_status_t append_data(const uint8_t* some_string, size_t len);
 void t_global_init_ecall(uint64_t id, const uint8_t* path, size_t len);
 void t_global_exit_ecall(void);
 
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/enclave/src/lib.rs b/rust-sgx-workspace/projects/ntc-tee-server/enclave/src/lib.rs
index d18f06d..a0bc329 100644
--- a/rust-sgx-workspace/projects/ntc-tee-server/enclave/src/lib.rs
+++ b/rust-sgx-workspace/projects/ntc-tee-server/enclave/src/lib.rs
@@ -4,22 +4,126 @@
 extern crate sgx_types;
 #[macro_use]
 extern crate sgx_tstd as std;
+extern crate serde_json;
 
 use std::io::{self, Write};
 use std::slice;
+use std::string::String;
+use std::vec::Vec;
 
+use serde_json::Value;
 use sgx_types::sgx_status_t;
 
-/// Does a test ecall
-///
 /// # Safety
 /// Caller needs to ensure that `some_string` points to a valid slice of length `some_len`
 #[no_mangle]
-pub unsafe extern "C" fn ecall_test(some_string: *const u8, some_len: usize) -> sgx_status_t {
+pub unsafe extern "C" fn append_data(some_string: *const u8, some_len: usize) -> sgx_status_t {
     let str_slice = unsafe { slice::from_raw_parts(some_string, some_len) };
     let _ = io::stdout().write(str_slice);
 
     println!("Message from the enclave");
 
+    // Test pool 1 - Import existing data pool from CosmosDB
+    let json_pool_1 = r#"
+    {
+        "pool": [
+            { 
+                "ID":1,
+                "Income":109748.717064175,
+                "Postal":41,
+                "WalletID":"9173f117-eaf5-443b-a405-c3d5e2aa5d99"
+                },
+                { 
+                "ID":2,
+                "Income":77356.0675380472,
+                "Postal":15,
+                "WalletID":"9f86ae7c-ac1c-4b8e-9daf-bd40ad13e157"
+                },
+                { 
+                "ID":3,
+                "Income":33746.4377853607,
+                "Postal":11,
+                "WalletID":"3e77ee27-b25b-4bcc-b9b8-d7107a633ae9"
+                },
+                { 
+                "ID":4,
+                "Income":37657.0518817567,
+                "Postal":48,
+                "WalletID":"67be8d2b-c31a-44b6-9cb0-6456072d3353"
+                },
+                { 
+                "ID":5,
+                "Income":27353.1866838295,
+                "Postal":5,
+                "WalletID":"412326e0-716a-4233-bae1-4cd199207893"
+                }
+        ]
+    }
+    "#;
+
+    // Test pool 2 - Import append pool from CosmosDB (Temp data pool)
+    let json_pool_2 = r#"
+    {
+        "pool": [
+            { 
+                "ID":6,
+                "Income":71540.129423949,
+                "Postal":34,
+                "WalletID":"dabcbe30-4ed0-4c3b-b6b3-aafb85312963"
+                },
+                { 
+                "ID":7,
+                "Income":7352.38903575921,
+                "Postal":41,
+                "WalletID":"fdcd0caa-48bf-446f-b00f-a90d646f55c3"
+                },
+                { 
+                "ID":8,
+                "Income":110742.078725787,
+                "Postal":7,
+                "WalletID":"f4f5cd1b-c2ad-4587-905d-47237ebdbd89"
+                },
+                { 
+                "ID":9,
+                "Income":129564.725166652,
+                "Postal":3,
+                "WalletID":"7e4e80c4-7e9b-4a6e-8d94-e4f72bde8233"
+                },
+                { 
+                "ID":10,
+                "Income":2964.80996131516,
+                "Postal":33,
+                "WalletID":"ecefdd47-aab3-4595-87f7-cf9bbef46a53"
+                }
+        ]
+    }
+    "#;
+
+    let pool_1 = serde_json::from_str::<Value>(&json_pool_1).expect("JSON was not well-formatted");
+    let pool_2 = serde_json::from_str::<Value>(&json_pool_2).expect("JSON was not well-formatted");
+
+    let pool_1_length = pool_1["pool"].as_array().unwrap().len();
+    let pool_2_length = pool_1["pool"].as_array().unwrap().len();
+
+    let mut new_pool: Vec<Value> = Vec::new();
+    for index in 0..pool_1_length {
+        new_pool.push(pool_1["pool"][index].clone());
+    }
+    for index in 0..pool_2_length {
+        new_pool.push(pool_2["pool"][index].clone());
+    }
+
+    let pool_string = serde_json::to_string(&new_pool).unwrap();
+
+    let json_start = r#"{"pool":"#;
+    let json_end: String = String::from("}");
+    let temp_pool = [json_start, &pool_string[..]].join("");
+    let pool = [temp_pool, json_end].join("");
+
+    let updated_pool = serde_json::from_str::<Value>(&pool).expect("JSON was not well-formatted");
+
+    // Seal updated pool and store on CosmosDB
+    println!("\n\n The updated pool {:#}", updated_pool);
+
     sgx_status_t::SGX_SUCCESS
 }
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/lib/libEnclave_u.a b/rust-sgx-workspace/projects/ntc-tee-server/lib/libEnclave_u.a
new file mode 100644
index 0000000..017f0e3
Binary files /dev/null and b/rust-sgx-workspace/projects/ntc-tee-server/lib/libEnclave_u.a differ
diff --git a/rust-sgx-workspace/projects/ntc-tee-server/obj/Enclave_u.o b/rust-sgx-workspace/projects/ntc-tee-server/obj/Enclave_u.o
new file mode 100644
index 0000000..a844495
Binary files /dev/null and b/rust-sgx-workspace/projects/ntc-tee-server/obj/Enclave_u.o differ
diff --git a/rust-workspace/crates/ntc-data-packages/tests/data_packages/json_schema.rs b/rust-workspace/crates/ntc-data-packages/tests/data_packages/json_schema.rs
index 1535525..97ef9e2 100644
--- a/rust-workspace/crates/ntc-data-packages/tests/data_packages/json_schema.rs
+++ b/rust-workspace/crates/ntc-data-packages/tests/data_packages/json_schema.rs
@@ -77,6 +77,27 @@ fn validate_example_person_schema() {
     json_dataset.validate().expect("validate should succeed");
 }
 
+#[test]
+fn validate_example_person_schema_age_missing() {
+    let json_dataset = JsonDataset {
+        schema: example_person_schema(),
+        data: json!({
+          "firstName": "Jane",
+          "lastName": "Doe",
+        }),
+    };
+    let err = json_dataset.validate().unwrap_err();
+    k9::snapshot!(
+        format_err(err),
+        r#"
+data validation failed
+
+Caused by:
+    validation errors: "age" is a required property (path= schema=/required)
+"#
+    );
+}
+
 #[test]
 fn validate_example_person_schema_invalid() {
     let json_dataset = JsonDataset {
@@ -120,7 +141,8 @@ fn example_person_schema() -> Value {
           "type": "integer",
           "minimum": 0
         }
-      }
+      },
+      "required": [ "firstName", "lastName", "age" ],
     })
 }