From 9a91ec65a157afab2dbed7e12df5d2a832ec24d5 Mon Sep 17 00:00:00 2001 From: chenpengyu Date: Mon, 7 Aug 2023 02:22:56 +0000 Subject: [PATCH] temp commit --- fuzz/CMakeLists.txt | 5 +- fuzz/sgx-stub-enclave/CMakeLists.txt | 81 +++++ fuzz/sgx-stub-enclave/sgx_stub.edl | 29 ++ fuzz/sgx-stub-enclave/sgx_stub_ecall.c | 327 +++++++++++++++++++++ fuzz/sgx-stub-enclave/sgx_stub_enclave.lds | 7 + fuzz/sgx-stub-enclave/sgx_stub_enclave.pem | 39 +++ fuzz/sgx-stub-enclave/sgx_stub_enclave.xml | 9 + fuzz/tls_init/CMakeLists.txt | 63 +++- fuzz/tls_init/fuzz_init.cc | 141 ++++++++- fuzz/tls_negotiate/CMakeLists.txt | 57 +++- fuzz/tls_server/CMakeLists.txt | 56 +++- fuzz/tls_transmit/CMakeLists.txt | 56 +++- 12 files changed, 836 insertions(+), 34 deletions(-) create mode 100644 fuzz/sgx-stub-enclave/CMakeLists.txt create mode 100644 fuzz/sgx-stub-enclave/sgx_stub.edl create mode 100644 fuzz/sgx-stub-enclave/sgx_stub_ecall.c create mode 100644 fuzz/sgx-stub-enclave/sgx_stub_enclave.lds create mode 100644 fuzz/sgx-stub-enclave/sgx_stub_enclave.pem create mode 100644 fuzz/sgx-stub-enclave/sgx_stub_enclave.xml diff --git a/fuzz/CMakeLists.txt b/fuzz/CMakeLists.txt index de3d568c..ac435a12 100644 --- a/fuzz/CMakeLists.txt +++ b/fuzz/CMakeLists.txt @@ -1,4 +1,7 @@ add_subdirectory(tls_init) add_subdirectory(tls_negotiate) add_subdirectory(tls_server) -add_subdirectory(tls_transmit) \ No newline at end of file +add_subdirectory(tls_transmit) +if(SGX) + add_subdirectory(sgx-stub-enclave) +endif() \ No newline at end of file diff --git a/fuzz/sgx-stub-enclave/CMakeLists.txt b/fuzz/sgx-stub-enclave/CMakeLists.txt new file mode 100644 index 00000000..ea36fb52 --- /dev/null +++ b/fuzz/sgx-stub-enclave/CMakeLists.txt @@ -0,0 +1,81 @@ +# Project name +project(sgx-stub-enclave) + +if(BUILD_FUZZ) + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/external/sgx-ssl/intel-sgx-ssl/src/intel-sgx-ssl/Linux/package/include + ) + + set(LIBRARY_DIRS ${INTEL_SGXSSL_LIB_PATH} + ${LIBCBOR_LIB_PATH} + ${CMAKE_BINARY_DIR}/src + ${CMAKE_BINARY_DIR}/src/crypto_wrappers/nullcrypto + ${CMAKE_BINARY_DIR}/src/crypto_wrappers/openssl + ${CMAKE_BINARY_DIR}/src/tls_wrappers/nulltls + ${CMAKE_BINARY_DIR}/src/tls_wrappers/openssl + ${CMAKE_BINARY_DIR}/src/verifiers/nullverifier + ${CMAKE_BINARY_DIR}/src/verifiers/sgx-ecdsa-qve + ${CMAKE_BINARY_DIR}/src/verifiers/tdx-ecdsa + ${CMAKE_BINARY_DIR}/src/verifiers/sgx-la + ${CMAKE_BINARY_DIR}/src/attesters/nullattester + ${CMAKE_BINARY_DIR}/src/attesters/sgx-ecdsa + ${CMAKE_BINARY_DIR}/src/attesters/sgx-la + ) + + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) +else() + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + include(CustomInstallDirs) + include(FindRatsTls) + if(NOT RATS_TLS_FOUND) + message(FATAL_ERROR "Failed to find rats_tls!") + endif() + include(FindSGX) + if(NOT SGX_FOUND) + message(FATAL_ERROR "Failed to find sgx!") + endif() + include(CompilerOptions) + include(SGXCommon) + + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl) + + set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) + + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl) +endif() + +include_directories(${INCLUDE_DIRS}) +link_directories(${LIBRARY_DIRS}) + +set(E_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/sgx_stub_ecall.c) +set(EDLS ${CMAKE_CURRENT_SOURCE_DIR}/sgx_stub.edl) +set(LDS ${CMAKE_CURRENT_SOURCE_DIR}/sgx_stub_enclave.lds) +set(DEPEND_TRUSTED_LIBS crypto_wrapper_nullcrypto + crypto_wrapper_openssl + tls_wrapper_nulltls + tls_wrapper_openssl + attester_nullattester + attester_sgx_ecdsa + attester_sgx_la + verifier_nullverifier + verifier_sgx_la + verifier_sgx_ecdsa_qve + verifier_tdx_ecdsa + rats_tls + cbor + ) + +# 不能开启 sample on +add_enclave_library(sgx_stub_enclave SRCS ${E_SRCS} EDL ${EDLS} TRUSTED_LIBS ${DEPEND_TRUSTED_LIBS} EDL_SEARCH_PATHS ${EDL_SEARCH_PATHS} LDSCRIPT ${LDS}) + +enclave_sign(sgx_stub_enclave KEY sgx_stub_enclave.pem CONFIG sgx_stub_enclave.xml) +add_dependencies(sgx_stub_enclave rats_tls) + +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/sgx_stub_enclave.signed.so + DESTINATION /usr/share/rats-tls/fuzz) \ No newline at end of file diff --git a/fuzz/sgx-stub-enclave/sgx_stub.edl b/fuzz/sgx-stub-enclave/sgx_stub.edl new file mode 100644 index 00000000..8eb85e1a --- /dev/null +++ b/fuzz/sgx-stub-enclave/sgx_stub.edl @@ -0,0 +1,29 @@ +enclave { + include "rats-tls/api.h" + include "internal/core.h" + include "sgx_eid.h" + + from "../../src/include/edl/rtls.edl" import *; + from "sgx_tsgxssl.edl" import *; + + trusted { + public int ecall_rtls_server_startup(rats_tls_log_level_t log_level, + [in, string] char *attester_type, + [in, string] char *verifier_type, + [in, string] char *tls_type, + [in, string] char *crypto_type, + unsigned long flags, + uint32_t s_ip, + uint16_t s_port); + public int ecall_rtls_client_startup(rats_tls_log_level_t log_level, + [in, string] char *attester_type, + [in, string] char *verifier_type, + [in, string] char *tls_type, + [in, string] char *crypto_type, + unsigned long flags, + uint32_t s_ip, + uint16_t s_port, + bool verdictd); + public int ecall_rtsl_fuzz_inti(rats_tls_conf_t conf); + }; +}; diff --git a/fuzz/sgx-stub-enclave/sgx_stub_ecall.c b/fuzz/sgx-stub-enclave/sgx_stub_ecall.c new file mode 100644 index 00000000..59b3cf2e --- /dev/null +++ b/fuzz/sgx-stub-enclave/sgx_stub_ecall.c @@ -0,0 +1,327 @@ +/* Copyright (c) 2021 Intel Corporation + * Copyright (c) 2020-2021 Alibaba Cloud + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "rats-tls/api.h" +#include "sgx_stub_t.h" + +int ecall_rtls_server_startup(rats_tls_log_level_t log_level, char *attester_type, + char *verifier_type, char *tls_type, char *crypto_type, + unsigned long flags, uint32_t s_ip, uint16_t s_port) +{ + rats_tls_conf_t conf; + + memset(&conf, 0, sizeof(conf)); + conf.log_level = log_level; + snprintf(conf.attester_type, sizeof(conf.attester_type), "%s", attester_type); + snprintf(conf.verifier_type, sizeof(conf.verifier_type), "%s", verifier_type); + snprintf(conf.tls_type, sizeof(conf.tls_type), "%s", tls_type); + snprintf(conf.crypto_type, sizeof(conf.crypto_type), "%s", crypto_type); + conf.flags = flags; + conf.cert_algo = RATS_TLS_CERT_ALGO_DEFAULT; + + /* Optional: Set some user-defined custom claims, which will be embedded in the certificate. */ + claim_t custom_claims[2] = { + { .name = "key_0", .value = (uint8_t *)"value_0", .value_size = sizeof("value_0") }, + { .name = "key_1", .value = (uint8_t *)"value_1", .value_size = sizeof("value_1") }, + }; + conf.custom_claims = (claim_t *)custom_claims; + conf.custom_claims_length = 2; + + int64_t sockfd; + int sgx_status = ocall_socket(&sockfd, RTLS_AF_INET, RTLS_SOCK_STREAM, 0); + if (sgx_status != SGX_SUCCESS || sockfd < 0) { + RTLS_ERR("Failed to call socket() %#x %d\n", sgx_status, sockfd); + return -1; + } + + int reuse = 1; + int ocall_ret = 0; + sgx_status = ocall_setsockopt(&ocall_ret, sockfd, RTLS_SOL_SOCKET, RTLS_SO_REUSEADDR, + (const void *)&reuse, sizeof(int)); + if (sgx_status != SGX_SUCCESS || ocall_ret < 0) { + RTLS_ERR("Failed to call setsockopt() %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + /* Set keepalive options */ + int flag = 1; + int tcp_keepalive_time = 30; + int tcp_keepalive_intvl = 10; + int tcp_keepalive_probes = 5; + sgx_status = ocall_setsockopt(&ocall_ret, sockfd, RTLS_SOL_SOCKET, RTLS_SO_KEEPALIVE, &flag, + sizeof(flag)); + if (sgx_status != SGX_SUCCESS || ocall_ret < 0) { + RTLS_ERR("Failed to call setsockopt() %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + sgx_status = ocall_setsockopt(&ocall_ret, sockfd, RTLS_SOL_TCP, RTLS_TCP_KEEPIDLE, + &tcp_keepalive_time, sizeof(tcp_keepalive_time)); + if (sgx_status != SGX_SUCCESS || ocall_ret < 0) { + RTLS_ERR("Failed to call setsockopt() %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + sgx_status = ocall_setsockopt(&ocall_ret, sockfd, RTLS_SOL_TCP, RTLS_TCP_KEEPINTVL, + &tcp_keepalive_intvl, sizeof(tcp_keepalive_intvl)); + if (sgx_status != SGX_SUCCESS || ocall_ret < 0) { + RTLS_ERR("Failed to call setsockopt() %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + sgx_status = ocall_setsockopt(&ocall_ret, sockfd, RTLS_SOL_TCP, RTLS_TCP_KEEPCNT, + &tcp_keepalive_probes, sizeof(tcp_keepalive_probes)); + if (sgx_status != SGX_SUCCESS || ocall_ret < 0) { + RTLS_ERR("Failed to call setsockopt() %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + struct rtls_sockaddr_in s_addr; + memset(&s_addr, 0, sizeof(s_addr)); + s_addr.sin_family = RTLS_AF_INET; + s_addr.sin_addr.s_addr = s_ip; + s_addr.sin_port = s_port; + + /* Bind the server socket */ + sgx_status = ocall_bind(&ocall_ret, sockfd, &s_addr, sizeof(s_addr)); + if (sgx_status != SGX_SUCCESS || ocall_ret == -1) { + RTLS_ERR("Failed to call bind(), %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + /* Listen for a new connection, allow 5 pending connections */ + sgx_status = ocall_listen(&ocall_ret, sockfd, 5); + if (sgx_status != SGX_SUCCESS || ocall_ret == -1) { + RTLS_ERR("Failed to call listen(), %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + /* rats-tls init */ + librats_tls_init(); + rats_tls_handle handle; + rats_tls_err_t ret = rats_tls_init(&conf, &handle); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to initialize rats tls %#x\n", ret); + return -1; + } + + ret = rats_tls_set_verification_callback(&handle, NULL); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to set verification callback %#x\n", ret); + return -1; + } + + /* Accept client connections */ + struct rtls_sockaddr_in c_addr; + uint32_t addrlen_in = sizeof(c_addr); + uint32_t addrlen_out; + while (1) { + RTLS_INFO("Waiting for a connection ...\n"); + + int64_t connd; + sgx_status = ocall_accept(&connd, sockfd, &c_addr, addrlen_in, &addrlen_out); + if (sgx_status != SGX_SUCCESS || connd < 0) { + RTLS_ERR("Failed to call accept() %#x %d\n", sgx_status, connd); + return -1; + } + + ret = rats_tls_negotiate(handle, connd); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to negotiate %#x\n", ret); + goto err; + } + + RTLS_DEBUG("Client connected successfully\n"); + + char buf[256]; + size_t len = sizeof(buf); + ret = rats_tls_receive(handle, buf, &len); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to receive %#x\n", ret); + goto err; + } + + if (len >= sizeof(buf)) + len = sizeof(buf) - 1; + buf[len] = '\0'; + + RTLS_INFO("Client: %s\n", buf); + + /* Reply back to the client */ + ret = rats_tls_transmit(handle, buf, &len); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to transmit %#x\n", ret); + goto err; + } + + ocall_close(&ocall_ret, connd); + } + + return 0; + +err: + /* Ignore the error code of cleanup in order to return the prepositional error */ + rats_tls_cleanup(handle); + return -1; +} + +int user_callback(void *args) +{ + rtls_evidence_t *ev = (rtls_evidence_t *)args; + + printf("verify_callback called, claims %p, claims_size %zu, args %p\n", ev->custom_claims, + ev->custom_claims_length, args); + for (size_t i = 0; i < ev->custom_claims_length; ++i) { + printf("custom_claims[%zu] -> name: '%s' value_size: %zu value: '%.*s'\n", i, + ev->custom_claims[i].name, ev->custom_claims[i].value_size, + (int)ev->custom_claims[i].value_size, ev->custom_claims[i].value); + } + return 1; +} + +int ecall_rtls_client_startup(rats_tls_log_level_t log_level, char *attester_type, + char *verifier_type, char *tls_type, char *crypto_type, + unsigned long flags, uint32_t s_ip, uint16_t s_port, bool verdictd) +{ + rats_tls_conf_t conf; + + memset(&conf, 0, sizeof(conf)); + conf.log_level = log_level; + snprintf(conf.attester_type, sizeof(conf.attester_type), "%s", attester_type); + snprintf(conf.verifier_type, sizeof(conf.verifier_type), "%s", verifier_type); + snprintf(conf.tls_type, sizeof(conf.tls_type), "%s", tls_type); + snprintf(conf.crypto_type, sizeof(conf.crypto_type), "%s", crypto_type); + conf.flags = flags; + conf.cert_algo = RATS_TLS_CERT_ALGO_DEFAULT; + + /* Create a socket that uses an internet IPv4 address, + * Sets the socket to be stream based (TCP), + * 0 means choose the default protocol. + */ + int64_t sockfd; + int sgx_status = ocall_socket(&sockfd, RTLS_AF_INET, RTLS_SOCK_STREAM, 0); + if (sgx_status != SGX_SUCCESS || sockfd < 0) { + RTLS_ERR("Failed to call socket() %#x %d\n", sgx_status, sockfd); + return -1; + } + + struct rtls_sockaddr_in s_addr; + memset(&s_addr, 0, sizeof(s_addr)); + s_addr.sin_family = RTLS_AF_INET; + s_addr.sin_addr.s_addr = s_ip; + s_addr.sin_port = s_port; + + /* Connect to the server */ + int ocall_ret = 0; + sgx_status = ocall_connect(&ocall_ret, sockfd, &s_addr, sizeof(s_addr)); + if (sgx_status != SGX_SUCCESS || ocall_ret == -1) { + RTLS_ERR("failed to call connect() %#x %d\n", sgx_status, ocall_ret); + return -1; + } + + /* rats-tls init */ + librats_tls_init(); + rats_tls_handle handle; + rats_tls_err_t ret = rats_tls_init(&conf, &handle); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to initialize rats tls %#x\n", ret); + return -1; + } + + ret = rats_tls_set_verification_callback(&handle, user_callback); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to set verification callback %#x\n", ret); + return -1; + } + + ret = rats_tls_negotiate(handle, (int)sockfd); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to negotiate %#x\n", ret); + goto err; + } + + const char *msg; + if (verdictd) + msg = "{ \"command\": \"echo\", \"data\": \"Hello and welcome to RATS-TLS!\\n\" }"; + else + msg = "Hello and welcome to RATS-TLS!\n"; + + size_t len = strlen(msg); + ret = rats_tls_transmit(handle, (void *)msg, &len); + if (ret != RATS_TLS_ERR_NONE || len != strlen(msg)) { + RTLS_ERR("Failed to transmit %#x\n", ret); + goto err; + } + + char buf[256]; + len = sizeof(buf); + ret = rats_tls_receive(handle, buf, &len); + if (ret != RATS_TLS_ERR_NONE) { + RTLS_ERR("Failed to receive %#x\n", ret); + goto err; + } + + if (len >= sizeof(buf)) + len = sizeof(buf) - 1; + buf[len] = '\0'; + + /* Server running in SGX Enclave will send mrenclave, mrsigner and hello message to client */ + if (len >= 2 * sizeof(sgx_measurement_t)) { + RTLS_INFO("Server's SGX identity:\n"); + RTLS_INFO(" . MRENCLAVE = "); + for (int i = 0; i < 32; ++i) + printf("%02x", (uint8_t)buf[i]); + printf("\n"); + RTLS_INFO(" . MRSIGNER = "); + for (int i = 32; i < 64; ++i) + printf("%02x", (uint8_t)buf[i]); + printf("\n"); + + memcpy(buf, buf + 2 * sizeof(sgx_measurement_t), + len - 2 * sizeof(sgx_measurement_t)); + buf[len - 2 * sizeof(sgx_measurement_t)] = '\0'; + + RTLS_INFO("Server:\n%s\n", buf); + } else { + /* Server not running in SGX Enlcave will only send hello message to client */ + RTLS_INFO("Server: %s\n", buf); + } + + if (verdictd) + msg = "Hello and welcome to RATS-TLS!\n"; + + /* Sanity check whether the response is expected */ + if (strcmp(msg, buf)) { + printf("Invalid response retrieved from rats-tls server\n"); + goto err; + } + + ret = rats_tls_cleanup(handle); + if (ret != RATS_TLS_ERR_NONE) + RTLS_ERR("Failed to cleanup %#x\n", ret); + + return ret; + +err: + /* Ignore the error code of cleanup in order to return the prepositional error */ + rats_tls_cleanup(handle); + return -1; +} + +int ecall_rtls_fuzz_init(rats_tls_conf_t conf){ + librats_tls_init(); + rats_tls_handle handle; + rats_tls_err_t ret = rats_tls_init(&conf, &handle); + return -1; +} \ No newline at end of file diff --git a/fuzz/sgx-stub-enclave/sgx_stub_enclave.lds b/fuzz/sgx-stub-enclave/sgx_stub_enclave.lds new file mode 100644 index 00000000..3e39bc2b --- /dev/null +++ b/fuzz/sgx-stub-enclave/sgx_stub_enclave.lds @@ -0,0 +1,7 @@ +{ + global: + g_global_data_sim; + g_global_data; + local: + *; +}; diff --git a/fuzz/sgx-stub-enclave/sgx_stub_enclave.pem b/fuzz/sgx-stub-enclave/sgx_stub_enclave.pem new file mode 100644 index 00000000..529d07be --- /dev/null +++ b/fuzz/sgx-stub-enclave/sgx_stub_enclave.pem @@ -0,0 +1,39 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIG4gIBAAKCAYEAroOogvsj/fZDZY8XFdkl6dJmky0lRvnWMmpeH41Bla6U1qLZ +AmZuyIF+mQC/cgojIsrBMzBxb1kKqzATF4+XwPwgKz7fmiddmHyYz2WDJfAjIveJ +ZjdMjM4+EytGlkkJ52T8V8ds0/L2qKexJ+NBLxkeQLfV8n1mIk7zX7jguwbCG1Pr +nEMdJ3Sew20vnje+RsngAzdPChoJpVsWi/K7cettX/tbnre1DL02GXc5qJoQYk7b +3zkmhz31TgFrd9VVtmUGyFXAysuSAb3EN+5VnHGr0xKkeg8utErea2FNtNIgua8H +ONfm9Eiyaav1SVKzPHlyqLtcdxH3I8Wg7yqMsaprZ1n5A1v/levxnL8+It02KseD +5HqV4rf/cImSlCt3lpRg8U5E1pyFQ2IVEC/XTDMiI3c+AR+w2jSRB3Bwn9zJtFlW +KHG3m1xGI4ck+Lci1JvWWLXQagQSPtZTsubxTQNx1gsgZhgv1JHVZMdbVlAbbRMC +1nSuJNl7KPAS/VfzAgEDAoIBgHRXxaynbVP5gkO0ug6Qw/E27wzIw4SmjsxG6Wpe +K7kfDeRskKxESdsA/xCrKkwGwhcx1iIgS5+Qscd1Yg+1D9X9asd/P7waPmWoZd+Z +AhlKwhdPsO7PiF3e1AzHhGQwsUTt/Y/aSI1MpHBvy2/s1h9mFCslOUxTmWw0oj/Q +ldIEgWeNR72CE2+jFIJIyml6ftnb6qzPiga8Bm48ubKh0kvySOqnkmnPzgh+JBD6 +JnBmtZbfPT97bwTT+N6rnPqOOApvfHPf15kWI8yDbprG1l4OCUaIUH1AszxLd826 +5IPM+8gINLRDP1MA6azECPjTyHXhtnSIBZCyWSVkc05vYmNXYUNiXWMajcxW9M02 +wKzFELO8NCEAkaTPxwo4SCyIjUxiK1LbQ9h8PSy4c1+gGP4LAMR8xqP4QKg6zdu9 +osUGG/xRe/uufgTBFkcjqBHtK5L5VI0jeNIUAgW/6iNbYXjBMJ0GfauLs+g1VsOm +WfdgXzsb9DYdMa0OXXHypmV4GwKBwQDUwQj8RKJ6c8cT4vcWCoJvJF00+RFL+P3i +Gx2DLERxRrDa8AVGfqaCjsR+3vLgG8V/py+z+dxZYSqeB80Qeo6PDITcRKoeAYh9 +xlT3LJOS+k1cJcEmlbbO2IjLkTmzSwa80fWexKu8/Xv6vv15gpqYl1ngYoqJM3pd +vzmTIOi7MKSZ0WmEQavrZj8zK4endE3v0eAEeQ55j1GImbypSf7Idh7wOXtjZ7WD +Dg6yWDrri+AP/L3gClMj8wsAxMV4ZR8CgcEA0fzDHkFa6raVOxWnObmRoDhAtE0a +cjUj976NM5yyfdf2MrKy4/RhdTiPZ6b08/lBC/+xRfV3xKVGzacm6QjqjZrUpgHC +0LKiZaMtccCJjLtPwQd0jGQEnKfMFaPsnhOc5y8qVkCzVOSthY5qhz0XNotHHFmJ +gffVgB0iqrMTvSL7IA2yqqpOqNRlhaYhNl8TiFP3gIeMtVa9rZy31JPgT2uJ+kfo +gV7sdTPEjPWZd7OshGxWpT6QfVDj/T9T7L6tAoHBAI3WBf2DFvxNL2KXT2QHAZ9t +k3imC4f7U+wSE6zILaDZyzygA4RUbwG0gv8/TJVn2P/Eynf76DuWHGlaiLWnCbSz +Az2DHBQBBaku409zDQym3j1ugMRjzzSQWzJg0SIyBH3hTmnYcn3+Uqcp/lEBvGW6 +O+rsXFt3pukqJmIV8HzLGGaLm62BHUeZf3dyWm+i3p/hQAL7Xvu04QW70xuGqdr5 +afV7p5eaeQIJXyGQJ0eylV/90+qxjMKiB1XYg6WYvwKBwQCL/ddpgOdHJGN8uRom +e7Zq0Csi3hGheMKlKbN3vcxT5U7MdyHtTZZOJbTvxKNNUNYH/8uD+PqDGNneb29G +BfGzvI3EASyLIcGZF3OhKwZd0jUrWk2y7Vhob91jwp2+t73vdMbkKyI4mHOuXvGv +fg95si9oO7EBT+Oqvhccd2J+F1IVXncccYnF4u5ZGWt5lLewN/pVr7MjjykeaHqN +t+rfnQam2psA6fL4zS2zTmZPzR2tnY8Y1GBTi0Ko1OKd1HMCgcAb5cB/7/AQlhP9 +yQa04PLH9ygQkKKptZp7dy5WcWRx0K/hAHRoi2aw1wZqfm7VBNu2SLcs90kCCCxp +6C5sfJi6b8NpNbIPC+sc9wsFr7pGo9SFzQ78UlcWYK2Gu2FxlMjonhka5hvo4zvg +WxlpXKEkaFt3gLd92m/dMqBrHfafH7VwOJY2zT3WIpjwuk0ZzmRg5p0pG/svVQEH +NZmwRwlopysbR69B/n1nefJ84UO50fLh5s5Zr3gBRwbWNZyzhXk= +-----END RSA PRIVATE KEY----- diff --git a/fuzz/sgx-stub-enclave/sgx_stub_enclave.xml b/fuzz/sgx-stub-enclave/sgx_stub_enclave.xml new file mode 100644 index 00000000..733dc898 --- /dev/null +++ b/fuzz/sgx-stub-enclave/sgx_stub_enclave.xml @@ -0,0 +1,9 @@ + + 0 + 0 + 0x400000 + 0x1000000 + 10 + 1 + 0 + diff --git a/fuzz/tls_init/CMakeLists.txt b/fuzz/tls_init/CMakeLists.txt index ad0d60fa..1cc1f38d 100644 --- a/fuzz/tls_init/CMakeLists.txt +++ b/fuzz/tls_init/CMakeLists.txt @@ -7,13 +7,46 @@ if(NOT SGX) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}") endif() -set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include - ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl - ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls - ${RATS_TLS_INSTALL_INCLUDE_PATH} - ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl - ) -set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) +if(SGX) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + include(CustomInstallDirs) + include(FindRatsTls) + if(NOT RATS_TLS_FOUND) + message(FATAL_ERROR "Failed to find rats_tls!") + endif() + + include(FindSGX) + if(NOT SGX_FOUND) + message(FATAL_ERROR "Failed to find sgx!") + endif() + + include(CompilerOptions) + include(SGXCommon) + + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls + ) + list(APPEND LIBRARY_DIRS ${CMAKE_BINARY_DIR}/src/sgx/untrust + ${CMAKE_BINARY_DIR}/samples/sgx-stub-enclave + ) + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(DEPEND_UNTRUSTED_LIBS ${CMAKE_BINARY_DIR}/src/sgx/untrust/librats_tls_u.a) + +else() + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls + ${RATS_TLS_INSTALL_INCLUDE_PATH} + ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl + ) + set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) +endif() include_directories(${INCLUDE_DIRS}) link_directories(${LIBRARY_DIRS}) @@ -21,9 +54,19 @@ link_directories(${LIBRARY_DIRS}) # Set source file set(SOURCES fuzz_init.cc) -# Generate bin file -add_executable(${PROJECT_NAME} ${SOURCES}) -target_link_libraries(${PROJECT_NAME} rats_tls) +if(SGX) + set(EDLS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave/sgx_stub.edl) + add_untrusted_executable(${PROJECT_NAME} + SRCS ${SOURCES} + UNTRUSTED_LIBS ${DEPEND_UNTRUSTED_LIBS} + EDL ${EDLS} + EDL_SEARCH_PATHS ${EDL_SEARCH_PATHS}) + add_dependencies(${PROJECT_NAME} sgx_stub_enclave-sign) +else() + # Generate bin file + add_executable(${PROJECT_NAME} ${SOURCES}) + target_link_libraries(${PROJECT_NAME} rats_tls) +endif() install(TARGETS ${PROJECT_NAME} DESTINATION /usr/share/rats-tls/fuzz) diff --git a/fuzz/tls_init/fuzz_init.cc b/fuzz/tls_init/fuzz_init.cc index 6fc07590..30a5a27d 100644 --- a/fuzz/tls_init/fuzz_init.cc +++ b/fuzz/tls_init/fuzz_init.cc @@ -7,15 +7,145 @@ extern "C" { #include #include #include +#include #include "rats-tls/api.h" #include "rats-tls/log.h" #include "rats-tls/claim.h" #include "internal/core.h" + } #include #include #define CUSTOM_CLAIMS_SIZE 10 +#define FUZZ_IP "127.0.0.1" +#define FUZZ_PORT 1234 +#define SGX + +#ifdef SGX + +#include +#include +#include "sgx_stub_u.h" + +#define ENCLAVE_FILENAME "sgx_stub_enclave.signed.so" + +static sgx_enclave_id_t load_enclave(bool debug_enclave) +{ + sgx_launch_token_t t; + + memset(t, 0, sizeof(t)); + + sgx_enclave_id_t eid; + int updated = 0; + int ret = sgx_create_enclave(ENCLAVE_FILENAME, debug_enclave, &t, &updated, &eid, NULL); + if (ret != SGX_SUCCESS) { + RTLS_ERR("Failed to load enclave %d\n", ret); + return 0; + } + + RTLS_INFO("Success to load enclave with enclave id %ld\n", eid); + + return eid; +} + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data,size_t size){ + + rats_tls_conf_t conf; + if(size < sizeof(conf) + 10 * sizeof(claim_t) + 50 * 10 + 100){ + return 0; + } + + FuzzedDataProvider fuzzed_data(data + sizeof(conf) , size -sizeof(conf)); + + FuzzedDataProvider fuzzed_data(data + sizeof(conf), size - sizeof(conf)); + + char attester_types[10][25] = { "", "nullattester", "sgx_la", "csv", + "sev", "sev_snp", "tdx_ecdsa", "sgx_ecdsa" }; + strcpy(attester_types[8], fuzzed_data.ConsumeBytesWithTerminator(20, '\0').data()); + if (fuzzed_data.remaining_bytes() < 0) { + return 0; + } + for (int i = 0; i < 9; i++) { + char verifier_types[10][25] = { "", "nullverifier", "sgx_la", + "csv", "sev", "sev_snp", + "tdx_ecdsa", "tdx_ecdsa", "sgx_ecdsa_qve" }; + strcpy(verifier_types[9], fuzzed_data.ConsumeBytesWithTerminator(20, '\0').data()); + if (fuzzed_data.remaining_bytes() < 0) { + return 0; + } + for (int j = 0; j < 10; j++) { + char tls_types[4][25] = { "", "nulltls", "openssl" }; + strcpy(tls_types[3], + fuzzed_data.ConsumeBytesWithTerminator(20, '\0').data()); + if (fuzzed_data.remaining_bytes() < 0) { + return 0; + } + for (int k = 0; k < 4; k++) { + char crypto_types[4][25] = { "", "nullcrypto", "openssl" }; + strcpy(crypto_types[3], + fuzzed_data.ConsumeBytesWithTerminator(20, '\0').data()); + if (fuzzed_data.remaining_bytes() < 0) { + return 0; + } + for (int l = 0; l < 4; l++) { + memcpy(&conf, data, sizeof(conf)); + conf.log_level = RATS_TLS_LOG_LEVEL_DEFAULT; + conf.api_version = 0; + + strcpy(conf.attester_type, attester_types[i]); + strcpy(conf.verifier_type, verifier_types[j]); + strcpy(conf.tls_type, tls_types[k]); + strcpy(conf.crypto_type, crypto_types[l]); + + conf.cert_algo = RATS_TLS_CERT_ALGO_DEFAULT; + conf.flags = fuzzed_data.ConsumeIntegral(); + + claim_t custom_claims[CUSTOM_CLAIMS_SIZE]; + std::vector str_lists; + for (int c = 0; c < CUSTOM_CLAIMS_SIZE; c++) { + std::vector vec_str = + fuzzed_data.ConsumeBytesWithTerminator( + 50, '\0'); + std::string str(vec_str.begin(), vec_str.end()); + str_lists.push_back(str); + custom_claims[c].value = + (uint8_t *)str_lists[c].c_str(); + custom_claims[c].value_size = + (strlen(str_lists[c].c_str()) + 1) * + sizeof(char); + if (fuzzed_data.remaining_bytes() <= 0) { + return 0; + } + custom_claims[c].name = "key"; + } + conf.custom_claims = (claim_t *)custom_claims; + conf.custom_claims_length = CUSTOM_CLAIMS_SIZE; + + for(int t=0;t<2;t++){ + sgx_enclave_id_t enclave_id; + if(t%2==0){ + enclave_id = load_enclave(true); + }else{ + enclave_id = load_enclave(false); + } + int ret = 0; + + } + rats_tls_handle handle; + rats_tls_err_t err = rats_tls_init(&conf, &handle); + } + } + } + } + + + + + return 0; +} + +#else extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { @@ -95,5 +225,12 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) return 0; - return 0; -} \ No newline at end of file + + rats_tls_handle handle; + rats_tls_err_t err = rats_tls_init(&conf,&handle); + return 0; + + +} + +#endif /* For Occlum and host builds */ diff --git a/fuzz/tls_negotiate/CMakeLists.txt b/fuzz/tls_negotiate/CMakeLists.txt index ecb6498c..e29b26d7 100644 --- a/fuzz/tls_negotiate/CMakeLists.txt +++ b/fuzz/tls_negotiate/CMakeLists.txt @@ -7,13 +7,46 @@ if(NOT SGX) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}") endif() -set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include +if(SGX) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + include(CustomInstallDirs) + include(FindRatsTls) + if(NOT RATS_TLS_FOUND) + message(FATAL_ERROR "Failed to find rats_tls!") + endif() + + include(FindSGX) + if(NOT SGX_FOUND) + message(FATAL_ERROR "Failed to find sgx!") + endif() + + include(CompilerOptions) + include(SGXCommon) + + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls - ${RATS_TLS_INSTALL_INCLUDE_PATH} - ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl ) -set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) + list(APPEND LIBRARY_DIRS ${CMAKE_BINARY_DIR}/src/sgx/untrust + ${CMAKE_BINARY_DIR}/samples/sgx-stub-enclave + ) + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(DEPEND_UNTRUSTED_LIBS ${CMAKE_BINARY_DIR}/src/sgx/untrust/librats_tls_u.a) + +else() + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls + ${RATS_TLS_INSTALL_INCLUDE_PATH} + ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl + ) + set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) +endif() include_directories(${INCLUDE_DIRS}) link_directories(${LIBRARY_DIRS}) @@ -21,9 +54,19 @@ link_directories(${LIBRARY_DIRS}) # Set source file set(SOURCES fuzz_negotiate.cc) -# Generate bin file -add_executable(${PROJECT_NAME} ${SOURCES}) -target_link_libraries(${PROJECT_NAME} rats_tls) +if(SGX) + set(EDLS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave/sgx_stub.edl) + add_untrusted_executable(${PROJECT_NAME} + SRCS ${SOURCES} + UNTRUSTED_LIBS ${DEPEND_UNTRUSTED_LIBS} + EDL ${EDLS} + EDL_SEARCH_PATHS ${EDL_SEARCH_PATHS}) + add_dependencies(${PROJECT_NAME} sgx_stub_enclave-sign) +else() + # Generate bin file + add_executable(${PROJECT_NAME} ${SOURCES}) + target_link_libraries(${PROJECT_NAME} rats_tls) +endif() install(TARGETS ${PROJECT_NAME} DESTINATION /usr/share/rats-tls/fuzz) diff --git a/fuzz/tls_server/CMakeLists.txt b/fuzz/tls_server/CMakeLists.txt index 310e2a99..409ed229 100644 --- a/fuzz/tls_server/CMakeLists.txt +++ b/fuzz/tls_server/CMakeLists.txt @@ -6,13 +6,45 @@ if(NOT SGX) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}") endif() -set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include +if(SGX) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + include(CustomInstallDirs) + include(FindRatsTls) + if(NOT RATS_TLS_FOUND) + message(FATAL_ERROR "Failed to find rats_tls!") + endif() + + include(FindSGX) + if(NOT SGX_FOUND) + message(FATAL_ERROR "Failed to find sgx!") + endif() + + include(CompilerOptions) + include(SGXCommon) + + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls - ${RATS_TLS_INSTALL_INCLUDE_PATH} - ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl ) -set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) + list(APPEND LIBRARY_DIRS ${CMAKE_BINARY_DIR}/src/sgx/untrust + ${CMAKE_BINARY_DIR}/samples/sgx-stub-enclave + ) + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(DEPEND_UNTRUSTED_LIBS ${CMAKE_BINARY_DIR}/src/sgx/untrust/librats_tls_u.a) +else() + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls + ${RATS_TLS_INSTALL_INCLUDE_PATH} + ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl + ) + set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) +endif() include_directories(${INCLUDE_DIRS}) link_directories(${LIBRARY_DIRS}) @@ -20,9 +52,19 @@ link_directories(${LIBRARY_DIRS}) # Set source file set(SOURCES fuzz_server.cc) -# Generate bin file -add_executable(${PROJECT_NAME} ${SOURCES}) -target_link_libraries(${PROJECT_NAME} rats_tls) +if(SGX) + set(EDLS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave/sgx_stub.edl) + add_untrusted_executable(${PROJECT_NAME} + SRCS ${SOURCES} + UNTRUSTED_LIBS ${DEPEND_UNTRUSTED_LIBS} + EDL ${EDLS} + EDL_SEARCH_PATHS ${EDL_SEARCH_PATHS}) + add_dependencies(${PROJECT_NAME} sgx_stub_enclave-sign) +else() + # Generate bin file + add_executable(${PROJECT_NAME} ${SOURCES}) + target_link_libraries(${PROJECT_NAME} rats_tls) +endif() install(TARGETS ${PROJECT_NAME} DESTINATION /usr/share/rats-tls/fuzz) diff --git a/fuzz/tls_transmit/CMakeLists.txt b/fuzz/tls_transmit/CMakeLists.txt index d285e5bd..84a0a5f9 100644 --- a/fuzz/tls_transmit/CMakeLists.txt +++ b/fuzz/tls_transmit/CMakeLists.txt @@ -7,13 +7,45 @@ if(NOT SGX) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}") endif() -set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include +if(SGX) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + include(CustomInstallDirs) + include(FindRatsTls) + if(NOT RATS_TLS_FOUND) + message(FATAL_ERROR "Failed to find rats_tls!") + endif() + + include(FindSGX) + if(NOT SGX_FOUND) + message(FATAL_ERROR "Failed to find sgx!") + endif() + + include(CompilerOptions) + include(SGXCommon) + + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls - ${RATS_TLS_INSTALL_INCLUDE_PATH} - ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl ) -set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) + list(APPEND LIBRARY_DIRS ${CMAKE_BINARY_DIR}/src/sgx/untrust + ${CMAKE_BINARY_DIR}/samples/sgx-stub-enclave + ) + set(EDL_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ) + set(DEPEND_UNTRUSTED_LIBS ${CMAKE_BINARY_DIR}/src/sgx/untrust/librats_tls_u.a) +else() + set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/edl + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/include/rats-tls + ${RATS_TLS_INSTALL_INCLUDE_PATH} + ${RATS_TLS_INSTALL_INCLUDE_PATH}/edl + ) + set(LIBRARY_DIRS ${RATS_TLS_INSTALL_LIB_PATH}) +endif() include_directories(${INCLUDE_DIRS}) link_directories(${LIBRARY_DIRS}) @@ -21,9 +53,19 @@ link_directories(${LIBRARY_DIRS}) # Set source file set(SOURCES fuzz_transmit.cc) -# Generate bin file -add_executable(${PROJECT_NAME} ${SOURCES}) -target_link_libraries(${PROJECT_NAME} rats_tls) +if(SGX) + set(EDLS ${CMAKE_CURRENT_SOURCE_DIR}/../sgx-stub-enclave/sgx_stub.edl) + add_untrusted_executable(${PROJECT_NAME} + SRCS ${SOURCES} + UNTRUSTED_LIBS ${DEPEND_UNTRUSTED_LIBS} + EDL ${EDLS} + EDL_SEARCH_PATHS ${EDL_SEARCH_PATHS}) + add_dependencies(${PROJECT_NAME} sgx_stub_enclave-sign) +else() + # Generate bin file + add_executable(${PROJECT_NAME} ${SOURCES}) + target_link_libraries(${PROJECT_NAME} rats_tls) +endif() install(TARGETS ${PROJECT_NAME} DESTINATION /usr/share/rats-tls/fuzz)