diff --git a/CMakeLists.txt b/CMakeLists.txt index a75bcd3e041..a9dd9dbca06 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -36,6 +36,9 @@ set(GCOV ${GCOV} CACHE STRING "Choose the target of Gcov: ON OFF, and default i set(STACK_USAGE ${STACK_USAGE} CACHE STRING "Choose the target of STACK_USAGE: ON OFF, and default is OFF" FORCE) set(BUILD_LINUX_SHARED_LIB ${BUILD_LINUX_SHARED_LIB} CACHE STRING "Choose if libspdm shared library should be built for linux: ON OFF, and default is OFF" FORCE) set(X509_IGNORE_CRITICAL ${X509_IGNORE_CRITICAL} CACHE STRING "Choose if libspdm-provided cryptography libraries (OpenSSL and MbedTLS) ignore unsupported critical extensions in certificates : ON OFF, and default is OFF" FORCE) +set(DEVICE ${DEVICE} CACHE STRING "Choose the test device: sample tpm, and default is sample" FORCE) + +option(LIBSPDM_TPM_SUPPORT "Add TPM support in crypt_ext" OFF) if(NOT GCOV) set(GCOV "OFF") @@ -53,6 +56,11 @@ if(NOT X509_IGNORE_CRITICAL) set(X509_IGNORE_CRITICAL "OFF") endif() +if (NOT DEVICE) + set(DEVICE "sample") +endif() + + set(LIBSPDM_DIR ${PROJECT_SOURCE_DIR}) # @@ -62,6 +70,7 @@ set(COMPILED_LIBCRYPTO_PATH ${COMPILED_LIBCRYPTO_PATH} CACHE STRING "Optionally set(COMPILED_LIBSSL_PATH ${COMPILED_LIBSSL_PATH} CACHE STRING "Optionally provide a path to libssl" FORCE) message("CMAKE_GENERATOR = ${CMAKE_GENERATOR}") +message("DEVICE = ${DEVICE}") if(ARCH STREQUAL "x64") message("ARCH = x64") @@ -213,6 +222,14 @@ else() message(FATAL_ERROR "Unknown CRYPTO") endif() +if (LIBSPDM_TPM_SUPPORT) + if (NOT CRYPTO STREQUAL "openssl") + message(FATAL_ERROR "${CRYPTO} does not support TPM") + endif () + message(STATUS "crypt_ext tpm supported enabled") + add_definitions(-DLIBSPDM_TPM_SUPPORT=1) +endif() + if (X509_IGNORE_CRITICAL STREQUAL "ON") if (CRYPTO STREQUAL "openssl") add_definitions(-DOPENSSL_IGNORE_CRITICAL=1) @@ -981,7 +998,7 @@ if(ENABLE_CODEQL STREQUAL "ON") add_subdirectory(os_stub/platform_lib) add_subdirectory(os_stub/platform_lib_null) add_subdirectory(os_stub/malloclib) - add_subdirectory(os_stub/spdm_device_secret_lib_sample) + add_subdirectory(os_stub/spdm_device_secret_lib_${DEVICE}) add_subdirectory(os_stub/spdm_device_secret_lib_null) add_subdirectory(os_stub/spdm_cert_verify_callback_sample) add_subdirectory(os_stub/cryptlib_null) @@ -1020,7 +1037,7 @@ else() add_subdirectory(os_stub/platform_lib) add_subdirectory(os_stub/platform_lib_null) add_subdirectory(os_stub/malloclib) - add_subdirectory(os_stub/spdm_device_secret_lib_sample) + add_subdirectory(os_stub/spdm_device_secret_lib_${DEVICE}) add_subdirectory(os_stub/spdm_device_secret_lib_null) add_subdirectory(os_stub/spdm_cert_verify_callback_sample) diff --git a/os_stub/cryptlib_openssl/CMakeLists.txt b/os_stub/cryptlib_openssl/CMakeLists.txt index b264daf7f7c..13b61ae433f 100644 --- a/os_stub/cryptlib_openssl/CMakeLists.txt +++ b/os_stub/cryptlib_openssl/CMakeLists.txt @@ -51,4 +51,12 @@ if(ENABLE_BINARY_BUILD STREQUAL "1") target_link_libraries(cryptlib_openssl PUBLIC ssl crypto memlib) else() target_link_libraries(cryptlib_openssl PUBLIC openssllib memlib) +target_link_libraries(cryptlib_openssl PUBLIC openssllib memlib) endif() + +if (LIBSPDM_TPM_SUPPORT) + target_sources(cryptlib_openssl + PRIVATE + tpm/tpm.c) + target_link_libraries(cryptlib_openssl PUBLIC tss2-esys tss2-tctildr tss2-rc) +endif () diff --git a/os_stub/cryptlib_openssl/pk/x509.c b/os_stub/cryptlib_openssl/pk/x509.c index 1c79377a832..842789c9b31 100644 --- a/os_stub/cryptlib_openssl/pk/x509.c +++ b/os_stub/cryptlib_openssl/pk/x509.c @@ -2036,7 +2036,6 @@ bool libspdm_x509_verify_cert_chain(const uint8_t *root_cert, size_t root_cert_l /* Verify current_cert with preceding cert;*/ - verify_flag = libspdm_x509_verify_cert(current_cert, current_cert_len, preceding_cert, preceding_cert_len); @@ -2458,6 +2457,7 @@ bool libspdm_gen_x509_csr_with_pqc( X509_NAME *x509_name; EVP_PKEY *private_key; EVP_PKEY *public_key; + bool owned_keys = false; EVP_MD *md; uint8_t *csr_p; STACK_OF(X509_EXTENSION) *exts; @@ -2536,11 +2536,13 @@ bool libspdm_gen_x509_csr_with_pqc( EVP_PKEY_free(private_key); EVP_PKEY_free(public_key); - private_key = EVP_PKEY_dup(ec_pkey); - public_key = EVP_PKEY_dup(ec_pkey); + /* Can't DUP hardware backed keys */ + private_key = ec_pkey; + public_key = ec_pkey; if (private_key == NULL || public_key == NULL) { goto free_all; } + owned_keys = true; break; } case LIBSPDM_CRYPTO_NID_SM2_DSA_P256: { @@ -2763,8 +2765,10 @@ bool libspdm_gen_x509_csr_with_pqc( EVP_MD_free((EVP_MD *)md); } X509_REQ_free(x509_req); - EVP_PKEY_free(private_key); - EVP_PKEY_free(public_key); + if (!owned_keys) { + EVP_PKEY_free(private_key); + EVP_PKEY_free(public_key); + } return (ret != 0); } diff --git a/os_stub/cryptlib_openssl/tpm/tpm.c b/os_stub/cryptlib_openssl/tpm/tpm.c new file mode 100644 index 00000000000..6a534e69b33 --- /dev/null +++ b/os_stub/cryptlib_openssl/tpm/tpm.c @@ -0,0 +1,301 @@ +/** + * Copyright Notice: + * Copyright 2021-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include "../../spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "internal/libspdm_crypt_lib.h" + +#include "../key_context.h" + +bool g_tpm_device_initialized = false; + +static libspdm_key_context *create_key_context(EVP_PKEY *pkey) +{ + libspdm_key_context *context = (libspdm_key_context *)malloc(sizeof(libspdm_key_context)); + context->evp_pkey = pkey; + return context; +} + +bool libspdm_tpm_device_init() +{ + OSSL_PROVIDER *tpm_provider = NULL; + + if (g_tpm_device_initialized) + return true; + + tpm_provider = OSSL_PROVIDER_load(NULL, "tpm2"); + if (tpm_provider == NULL){ + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "failed to load tpm2\n")); + return false; + } + + OSSL_PROVIDER_load(NULL, "default"); + OSSL_PROVIDER_load(NULL, "legacy"); + + g_tpm_device_initialized = true; + return true; +} + +static bool get_keyinfo(const char *handle, void **context, int keyinfo_type) +{ + OSSL_STORE_CTX *store_ctx = NULL; + OSSL_STORE_INFO *info = NULL; + + /* handle must look like: "tpm2tss:0x81010002" */ + store_ctx = OSSL_STORE_open_ex(handle, NULL, "provider=tpm2", NULL, NULL, NULL, NULL, NULL); + if (!store_ctx){ + return false; + } + + while ((info = OSSL_STORE_load(store_ctx)) != NULL) + { + if (OSSL_STORE_INFO_get_type(info) == keyinfo_type){ + switch (keyinfo_type) + { + case OSSL_STORE_INFO_PKEY: + *context = OSSL_STORE_INFO_get1_PKEY(info); + break; + case OSSL_STORE_INFO_PUBKEY: + *context = OSSL_STORE_INFO_get1_PUBKEY(info); + break; + case OSSL_STORE_INFO_CERT: + *context = OSSL_STORE_INFO_get1_CERT(info); + break; + } + break; + } + OSSL_STORE_INFO_free(info); + } + + OSSL_STORE_close(store_ctx); + + if (*context == NULL){ + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "no keyinfo %d foun on handle %s\n", keyinfo_type, handle)); + return false; + } + + return true; +} + +bool libspdm_tpm_get_private_key(void *handle, void **context) +{ + EVP_PKEY *pkey = NULL; + if (!get_keyinfo((const char *)handle, (void **)&pkey, OSSL_STORE_INFO_PKEY)){ + return false; + } + *context = create_key_context(pkey); + return true; +} + +bool libspdm_tpm_get_public_key(void *handle, void **context) +{ + EVP_PKEY *pkey = NULL; + if (!get_keyinfo((const char *)handle, (void **)&pkey, OSSL_STORE_INFO_PUBKEY)){ + return false; + } + *context = create_key_context(pkey); + return true; +} + +bool libspdm_tpm_read_pcr(uint32_t hash_algo, uint32_t index, void *buffer, size_t *size) +{ + TSS2_RC result; + TSS2_TCTI_CONTEXT *tcti_context = NULL; + ESYS_CONTEXT *context = NULL; + + TPML_PCR_SELECTION sel = { + .count = 1, + .pcrSelections = { + { + .sizeofSelect = 3, + .pcrSelect = {0x00, 0x00, 0x00, 0x00}, + }, + } + }; + + *size = 0; + switch (hash_algo) + { + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_256: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_256: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SM3_256: + sel.pcrSelections[0].hash = TPM2_ALG_SHA256; + *size = 32; + break; + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_384: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_384: + sel.pcrSelections[0].hash = TPM2_ALG_SHA384; + *size = 48; + break; + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_512: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_512: + sel.pcrSelections[0].hash = TPM2_ALG_SHA512; + *size = 64; + break; + default: + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "unsupported measurement hash algo %d\n", hash_algo)); + return false; + } + sel.pcrSelections[0].pcrSelect[(index - 1) / 8] |= 1 << ((index - 1) % 8); + + UINT32 uc; + TPML_PCR_SELECTION *out = NULL; + TPML_DIGEST *values = NULL; + + const char *tssconf = getenv("TPM2TOOLS_TCTI"); + if ((result = Tss2_TctiLdr_Initialize(tssconf, &tcti_context)) != TSS2_RC_SUCCESS){ + goto finish; + } + + /* TODO: abi version check */ + if ((result = Esys_Initialize(&context, tcti_context, NULL)) != TSS2_RC_SUCCESS){ + goto cleanup_tcti; + } + + if ((result = Esys_PCR_Read(context, ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &sel, &uc, &out, + &values)) != TSS2_RC_SUCCESS){ + goto cleanup_esys; + } + + memcpy(buffer, values->digests[0].buffer, *size); + +cleanup_esys: + Esys_Finalize(&context); + +cleanup_tcti: + Tss2_TctiLdr_Finalize(&tcti_context); + +finish: + return result == TSS2_RC_SUCCESS; +} + +bool libspdm_tpm_read_nv(uint32_t index, void **buffer, size_t *size) +{ + TSS2_RC rc; + TSS2_TCTI_CONTEXT *tcti = NULL; + ESYS_CONTEXT *esys = NULL; + ESYS_TR nv_tr = ESYS_TR_NONE; + + TPM2B_NV_PUBLIC *nv_pub = NULL; + TPM2B_NAME *nv_name = NULL; + TPMS_CAPABILITY_DATA *cap = NULL; + + UINT16 nv_size; + UINT32 max_nv_buf; + UINT16 offset = 0; + + *buffer = NULL; + *size = 0; + + rc = Tss2_TctiLdr_Initialize(getenv("TPM2TOOLS_TCTI"), &tcti); + if (rc != TSS2_RC_SUCCESS) + goto out; + + rc = Esys_Initialize(&esys, tcti, NULL); + if (rc != TSS2_RC_SUCCESS) + goto out; + + rc = Esys_TR_FromTPMPublic( + esys, + index, /* TPM handle */ + ESYS_TR_NONE, + ESYS_TR_NONE, + ESYS_TR_NONE, + &nv_tr); + if (rc != TSS2_RC_SUCCESS) + goto out; + + rc = Esys_NV_ReadPublic( + esys, + nv_tr, + ESYS_TR_NONE, + ESYS_TR_NONE, + ESYS_TR_NONE, + &nv_pub, + &nv_name); + if (rc != TSS2_RC_SUCCESS) + goto out; + + nv_size = nv_pub->nvPublic.dataSize; + + rc = Esys_GetCapability( + esys, + ESYS_TR_NONE, + ESYS_TR_NONE, + ESYS_TR_NONE, + TPM2_CAP_TPM_PROPERTIES, + TPM2_PT_NV_BUFFER_MAX, + 1, + NULL, + &cap); + if (rc != TSS2_RC_SUCCESS) + goto out; + + max_nv_buf = cap->data.tpmProperties.tpmProperty[0].value; + + *buffer = malloc(nv_size); + if (!*buffer) + goto out; + + while (offset < nv_size) + { + TPM2B_MAX_NV_BUFFER *chunk = NULL; + UINT16 to_read = (nv_size - offset > max_nv_buf) + ? max_nv_buf + : nv_size - offset; + + rc = Esys_NV_Read( + esys, + nv_tr, + nv_tr, + ESYS_TR_PASSWORD, + ESYS_TR_NONE, + ESYS_TR_NONE, + to_read, + offset, + &chunk); + if (rc != TSS2_RC_SUCCESS){ + Esys_Free(chunk); + goto out; + } + + memcpy((uint8_t *)(*buffer) + offset, + chunk->buffer, + chunk->size); + + offset += chunk->size; + Esys_Free(chunk); + } + + *size = nv_size; + rc = TSS2_RC_SUCCESS; + +out: + if (cap) + Esys_Free(cap); + if (nv_pub) + Esys_Free(nv_pub); + if (nv_name) + Esys_Free(nv_name); + if (nv_tr != ESYS_TR_NONE) + Esys_FlushContext(esys, nv_tr); + if (esys) + Esys_Finalize(&esys); + if (tcti) + Tss2_TctiLdr_Finalize(&tcti); + + return rc == TSS2_RC_SUCCESS; +} diff --git a/os_stub/openssllib/ossl_store.c b/os_stub/openssllib/ossl_store.c deleted file mode 100644 index 3667d7cee8b..00000000000 --- a/os_stub/openssllib/ossl_store.c +++ /dev/null @@ -1,156 +0,0 @@ -/** - * Copyright Notice: - * Copyright 2021-2022 DMTF. All rights reserved. - * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md - **/ - -#include /* The OSSL_STORE_INFO type numbers */ - -/* - * This function is cleanup ossl store. - * - * Dummy Implement - */ -void -ossl_store_cleanup_int ( - void - ) -{ -} - -static void * -file_open ( - void *provctx, - const char *uri - ) -{ - return NULL; -} - -const OSSL_DISPATCH ossl_file_store_functions[] = { - { OSSL_FUNC_STORE_OPEN, (void (*)(void)) file_open }, - { 0, NULL }, -}; - -OSSL_STORE_CTX * -OSSL_STORE_open ( - const char *uri, - const UI_METHOD *ui_method, - void *ui_data, - OSSL_STORE_post_process_info_fn post_process, - void *post_process_data - ) -{ - return NULL; -} - -OSSL_STORE_CTX * -OSSL_STORE_open_ex ( - const char *uri, - OSSL_LIB_CTX *libctx, - const char *propq, - const UI_METHOD *ui_method, - void *ui_data, - const OSSL_PARAM params[], - OSSL_STORE_post_process_info_fn post_process, - void *post_process_data - ) -{ - return NULL; -} - -int -OSSL_STORE_INFO_get_type ( - const OSSL_STORE_INFO *info - ) -{ - return 0; -} - -int -OSSL_STORE_find ( - OSSL_STORE_CTX *ctx, - const OSSL_STORE_SEARCH *search - ) -{ - return 0; -} - -OSSL_STORE_INFO * -OSSL_STORE_load ( - OSSL_STORE_CTX *ctx - ) -{ - return NULL; -} - -const char * -OSSL_STORE_INFO_get0_NAME ( - const OSSL_STORE_INFO *info - ) -{ - return NULL; -} - -X509 * -OSSL_STORE_INFO_get0_CERT ( - const OSSL_STORE_INFO *info - ) -{ - return NULL; -} - -X509_CRL * -OSSL_STORE_INFO_get0_CRL ( - const OSSL_STORE_INFO *info - ) -{ - return NULL; -} - -int -OSSL_STORE_eof ( - OSSL_STORE_CTX *ctx - ) -{ - return 0; -} - -int -OSSL_STORE_error ( - OSSL_STORE_CTX *ctx - ) -{ - return 0; -} - -int -OSSL_STORE_close ( - OSSL_STORE_CTX *ctx - ) -{ - return 0; -} - -void -OSSL_STORE_INFO_free ( - OSSL_STORE_INFO *info - ) -{ -} - -OSSL_STORE_SEARCH * -OSSL_STORE_SEARCH_by_name ( - X509_NAME *name - ) -{ - return NULL; -} - -void -OSSL_STORE_SEARCH_free ( - OSSL_STORE_SEARCH *search - ) -{ -} - diff --git a/os_stub/spdm_crypt_ext_lib/CMakeLists.txt b/os_stub/spdm_crypt_ext_lib/CMakeLists.txt index ffa8106b1a5..bef8e43bf12 100644 --- a/os_stub/spdm_crypt_ext_lib/CMakeLists.txt +++ b/os_stub/spdm_crypt_ext_lib/CMakeLists.txt @@ -12,4 +12,5 @@ target_sources(spdm_crypt_ext_lib PRIVATE spdm_crypt_ext.c spdm_crypt_ext_pqc.c -) \ No newline at end of file +) + diff --git a/os_stub/spdm_crypt_ext_lib/spdm_crypt_ext_lib.h b/os_stub/spdm_crypt_ext_lib/spdm_crypt_ext_lib.h index ee10753d919..2f12039a055 100644 --- a/os_stub/spdm_crypt_ext_lib/spdm_crypt_ext_lib.h +++ b/os_stub/spdm_crypt_ext_lib/spdm_crypt_ext_lib.h @@ -141,4 +141,97 @@ bool libspdm_measurement_hash_all(uint32_t measurement_hash_algo, const void *data, size_t data_size, uint8_t *hash_value); +#if LIBSPDM_TPM_SUPPORT +/** + * Initialize the TPM device backend for libspdm. + * + * This function performs TPM-specific initialization required before any + * cryptographic or measurement operations can be used by libspdm. + * Typical responsibilities include: + * - Establishing a connection with the TPM (hardware or simulator) + * - Initializing TPM contexts or sessions + * + * This function must be called once during platform initialization, + * before invoking any other libspdm TPM helper APIs. + * + * @retval true TPM device initialization succeeded. + * @retval false TPM device initialization failed. + */ +bool libspdm_tpm_device_init(); + +/** + * Retrieve a TPM-backed private key context. + * + * This function returns an opaque TPM context associated with a private key + * that is protected and managed by the TPM. The private key material itself + * is never exposed to the caller. + * + * The returned context is intended to be used internally by libspdm for + * cryptographic operations such as signing during SPDM authentication flows. + * + * @param[in] handle Optional TPM or device handle (implementation-defined). + * @param[out] context Pointer to receive the TPM private key context. + * + * @retval true Private key context was successfully retrieved. + * @retval false Failed to retrieve private key context. + */ +bool libspdm_tpm_get_private_key(void *handle, void **context); + +/** + * Retrieve a TPM-backed public key context. + * + * This function returns an opaque context representing the public portion + * of a TPM-managed key. The public key is typically used for certificate + * construction, verification, or SPDM key exchange operations. + * + * The format and lifetime of the returned context are implementation-defined. + * + * @param[in] handle Optional TPM or device handle (implementation-defined). + * @param[out] context Pointer to receive the TPM public key context. + * + * @retval true Public key context was successfully retrieved. + * @retval false Failed to retrieve public key context. + */ +bool libspdm_tpm_get_public_key(void *handle, void **context); + +/** + * Read a TPM Platform Configuration Register (PCR) value. + * + * This function reads the value of a specified PCR index using the requested + * hash algorithm and copies the result into the caller-provided buffer. + * + * If the provided buffer is too small, the required size is returned via + * the size parameter and the buffer is not modified. + * + * @param[in] hash_algo Hash algorithm used for the PCR bank. + * @param[in] index PCR index to read. + * @param[out] buffer Buffer to receive the PCR value. + * @param[in,out] size On input, size of buffer; on output, size used or required. + * + * @retval true PCR value was successfully read. + * @retval false Failed to read PCR value. + */ +bool libspdm_tpm_read_pcr(uint32_t hash_algo, uint32_t index, void *buffer, size_t *size); + +/** + * Read data from a TPM non-volatile (NV) index. + * + * This function reads the contents of a specified TPM NV index and returns + * a buffer containing the NV data. The buffer allocation and ownership are + * implementation-defined and must be documented by the platform. + * + * Typical use cases include retrieving certificates, measurements, + * or persistent configuration data stored in TPM NV. + * + * @param[in] index TPM NV index to read. + * @param[out] buffer Pointer to receive the allocated NV data buffer. + * @param[out] size Pointer to receive the size of the NV data. + * + * @retval true NV index was successfully read. + * @retval false Failed to read NV index. + */ +bool libspdm_tpm_read_nv(uint32_t index, void **buffer, size_t *size); + +#endif /* LIBSPDM_TPM_SUPPORT */ + #endif /* SPDM_CRYPT_EXT_LIB_H */ diff --git a/os_stub/spdm_device_secret_lib_tpm/CMakeLists.txt b/os_stub/spdm_device_secret_lib_tpm/CMakeLists.txt new file mode 100644 index 00000000000..47748d12086 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.5) + +add_library(spdm_device_secret_lib_tpm STATIC "") + +target_include_directories(spdm_device_secret_lib_tpm + PRIVATE + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_tpm + ${LIBSPDM_DIR}/include + ${LIBSPDM_DIR}/include/hal + ${LIBSPDM_DIR}/os_stub +) + +target_sources(spdm_device_secret_lib_tpm + PRIVATE + ../spdm_device_secret_lib_sample/chal.c + csr.c + ../spdm_device_secret_lib_sample/endpointinfo.c + ../spdm_device_secret_lib_sample/event.c + ../spdm_device_secret_lib_sample/key_ex.c + ../spdm_device_secret_lib_sample/key_pair.c + meas.c + lib.c + ../spdm_device_secret_lib_sample/psk.c + read_pub_cert.c + read_pub_cert_pqc.c + ../spdm_device_secret_lib_sample/read_special_cert.c + ../spdm_device_secret_lib_sample/set_cert.c + sign.c +) + +if ((ARCH STREQUAL "arm") OR (ARCH STREQUAL "aarch64")) + target_compile_options(spdm_device_secret_lib_tpm PRIVATE -DLIBSPDM_CPU_ARM) +endif() diff --git a/os_stub/spdm_device_secret_lib_tpm/csr.c b/os_stub/spdm_device_secret_lib_tpm/csr.c new file mode 100644 index 00000000000..c7782986f4d --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/csr.c @@ -0,0 +1,370 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" +#include "spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "keys.h" + +#if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP +bool libspdm_read_cached_last_csr_request(uint8_t **last_csr_request, + size_t *last_csr_request_len, + uint8_t req_csr_tracking_tag, + uint8_t *available_rsp_csr_tracking_tag) +{ + bool res; + uint8_t index; + size_t file_size; + uint8_t *file_data; + + file_data = NULL; + *available_rsp_csr_tracking_tag = 0; + char file[] = "cached_last_csr_x_request"; + /*change the file name, for example: cached_last_csr_1_request*/ + file[16] = (char)(req_csr_tracking_tag + '0'); + res = libspdm_read_input_file(file, (void **)last_csr_request, last_csr_request_len); + + for (index = 1; index <= SPDM_MAX_CSR_TRACKING_TAG; index++) { + file[16] = (char)(index + '0'); + libspdm_read_input_file(file, (void **)(&file_data), &file_size); + if (file_size == 0) { + *available_rsp_csr_tracking_tag |= (1 << index); + } else { + if (file_data != NULL) { + free(file_data); + } + } + } + + return res; +} + +bool libspdm_cache_last_csr_request(const uint8_t *last_csr_request, + size_t last_csr_request_len, + uint8_t req_csr_tracking_tag) +{ + bool res; + + char file[] = "cached_last_csr_x_request"; + /*change the file name, for example: cached_last_csr_1_request*/ + file[16] = (char)(req_csr_tracking_tag + '0'); + res = libspdm_write_output_file(file, last_csr_request, last_csr_request_len); + + return res; +} + +/*clean the cached last SPDM csr request*/ +bool libspdm_discard_all_cached_last_request() +{ + uint8_t index; + + char file[] = "cached_last_csr_x_request"; + + for (index = 1; index <= SPDM_MAX_CSR_TRACKING_TAG; index++) { + file[16] = (char)(index + '0'); + if (!libspdm_write_output_file(file, NULL, 0)) { + return false; + } + } + + return true; +} + +/* + * return true represent that: the device complete the csr by reset successfully + * return false represent that: the device complete the csr need reset + **/ +bool libspdm_read_cached_csr(uint8_t **csr_pointer, size_t *csr_len) +{ + bool res; + char *file; + + file = "test_csr/cached.csr"; + + res = libspdm_read_input_file(file, (void **)csr_pointer, csr_len); + return res; +} + +bool libspdm_gen_csr_without_reset(uint32_t base_hash_algo, uint32_t base_asym_algo, + uint32_t pqc_asym_algo, + uint8_t *requester_info, size_t requester_info_length, + uint8_t *opaque_data, uint16_t opaque_data_length, + size_t *csr_len, uint8_t *csr_pointer, + bool is_device_cert_model) +{ + bool result; + size_t hash_nid; + size_t asym_nid; + void *context; + size_t csr_buffer_size; + + csr_buffer_size = *csr_len; + + void *cert; + void *x509_ca_cert; + size_t cert_size; + + if (!libspdm_tpm_get_private_key(TPM_RESP_HANDLE, &context)) { + return false; + } + + if (!libspdm_tpm_read_nv(TPM_RESP_CERT, &cert, &cert_size)) { + return false; + } + + if (!libspdm_x509_construct_certificate(cert, cert_size, (uint8_t**)&x509_ca_cert)) { + return false; + } + + hash_nid = libspdm_get_hash_nid(base_hash_algo); + asym_nid = libspdm_get_aysm_nid(base_asym_algo); + + char * subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1"; + + result = libspdm_gen_x509_csr(hash_nid, asym_nid, + requester_info, requester_info_length, !is_device_cert_model, + context, subject_name, csr_len, csr_pointer, x509_ca_cert); + + if (csr_buffer_size < *csr_len) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO,"csr buffer is too small to store generated csr! \n")); + result = false; + } + + return result; +} + +bool libspdm_gen_csr( + void *spdm_context, + uint32_t base_hash_algo, uint32_t base_asym_algo, bool *need_reset, + const void *request, size_t request_size, + uint8_t *requester_info, size_t requester_info_length, + uint8_t *opaque_data, uint16_t opaque_data_length, + size_t *csr_len, uint8_t *csr_pointer, + bool is_device_cert_model, + bool *is_busy, bool *unexpected_request) +{ + bool result; + uint8_t *cached_last_csr_request; + size_t cached_last_request_len; + uint8_t *cached_csr; + size_t csr_buffer_size; + uint8_t rsp_csr_tracking_tag; + + csr_buffer_size = *csr_len; + + /*device gen csr need reset*/ + if (*need_reset) { + result = libspdm_read_cached_last_csr_request(&cached_last_csr_request, + &cached_last_request_len, + 1, &rsp_csr_tracking_tag); + + /*get the cached last csr request and csr*/ + if ((result) && + (cached_last_request_len == request_size) && + (libspdm_consttime_is_mem_equal(cached_last_csr_request, request, + request_size)) && + (libspdm_read_cached_csr(&cached_csr, csr_len)) && + (*csr_len != 0)) { + + /*get and save cached csr*/ + if (csr_buffer_size < *csr_len) { + free(cached_csr); + free(cached_last_csr_request); + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, + "csr buffer is too small to store cached csr! \n")); + return false; + } else { + libspdm_copy_mem(csr_pointer, csr_buffer_size, cached_csr, *csr_len); + } + + /*device don't need reset this time*/ + *need_reset = false; + + free(cached_csr); + free(cached_last_csr_request); + return true; + } else { + if (cached_last_csr_request != NULL) { + free(cached_last_csr_request); + } + + /*device need reset this time: cache the last_csr_request */ + result = libspdm_cache_last_csr_request(request, request_size, 1); + if (!result) { + return result; + } + + /*device need reset this time*/ + *need_reset = true; + return true; + } + } else { + result = libspdm_gen_csr_without_reset(base_hash_algo, base_asym_algo, 0, + requester_info, requester_info_length, + opaque_data, opaque_data_length, + csr_len, csr_pointer, is_device_cert_model); + return result; + } + +} + +#if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX +bool libspdm_gen_csr_ex( + void *spdm_context, + uint32_t base_hash_algo, uint32_t base_asym_algo, uint32_t pqc_asym_algo, + bool *need_reset, + const void *request, size_t request_size, + uint8_t *requester_info, size_t requester_info_length, + uint8_t *opaque_data, uint16_t opaque_data_length, + size_t *csr_len, uint8_t *csr_pointer, + uint8_t req_cert_model, + uint8_t *req_csr_tracking_tag, + uint8_t req_key_pair_id, + bool overwrite, + bool *is_busy, bool *unexpected_request) +{ + bool result; + uint8_t *cached_last_csr_request; + size_t cached_last_request_len; + uint8_t *cached_csr; + size_t csr_buffer_size; + uint8_t rsp_csr_tracking_tag; + uint8_t available_csr_tracking_tag; + uint8_t *request_change; + uint8_t index; + bool flag; + bool is_device_cert_model; + + available_csr_tracking_tag = 0; + csr_buffer_size = *csr_len; + + /*device gen csr need reset*/ + if (*need_reset) { + result = libspdm_read_cached_last_csr_request(&cached_last_csr_request, + &cached_last_request_len, + *req_csr_tracking_tag, + &rsp_csr_tracking_tag); + + for (index = 1; index <= SPDM_MAX_CSR_TRACKING_TAG; index++) { + if (((rsp_csr_tracking_tag >> index) & 0x01) == 0x01) { + available_csr_tracking_tag = index; + break; + } + } + + if (*req_csr_tracking_tag == 0) { + if (available_csr_tracking_tag == 0) { + /*no available tracking tag*/ + *is_busy = true; + return false; + } else { + flag = false; + } + } else { + /*matched csr_tracking_tag*/ + if (((rsp_csr_tracking_tag >> *req_csr_tracking_tag) & 0x01) == 0) { + flag = true; + } else { + /*unexpected*/ + return false; + } + } + + /*get the cached last csr request and csr*/ + if ((result) && + (cached_last_request_len == request_size) && + (libspdm_consttime_is_mem_equal(cached_last_csr_request, request, + request_size)) && + (libspdm_read_cached_csr(&cached_csr, csr_len)) && + (*csr_len != 0) && + (flag)) { + + /*get and save cached csr*/ + if (csr_buffer_size < *csr_len) { + free(cached_csr); + free(cached_last_csr_request); + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, + "csr buffer is too small to store cached csr! \n")); + return false; + } else { + libspdm_copy_mem(csr_pointer, csr_buffer_size, cached_csr, *csr_len); + } + + /*device don't need reset this time*/ + *need_reset = false; + + free(cached_csr); + free(cached_last_csr_request); + return true; + } else { + if (cached_last_csr_request != NULL) { + free(cached_last_csr_request); + } + + if ((*req_csr_tracking_tag == 0) && (available_csr_tracking_tag != 0)) { + request_change = malloc(request_size); + libspdm_copy_mem(request_change, request_size, request,request_size); + + if (overwrite) { + available_csr_tracking_tag = 1; + /*discard all previously generated CSRTrackingTags. */ + result = libspdm_discard_all_cached_last_request(); + if (!result) { + free(request_change); + return result; + } + } + + request_change[3] |= + (available_csr_tracking_tag << + SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET); + + /*device need reset this time: cache the last_csr_request */ + result = libspdm_cache_last_csr_request(request_change, + request_size, available_csr_tracking_tag); + if (!result) { + free(request_change); + return result; + } + + /*device need reset this time*/ + *need_reset = true; + *req_csr_tracking_tag = available_csr_tracking_tag; + free(request_change); + return true; + } else { + /*the device is busy*/ + *is_busy = true; + return false; + } + } + } else { + if (req_cert_model == SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT) { + is_device_cert_model = true; + } else { + is_device_cert_model = false; + } + result = libspdm_gen_csr_without_reset(base_hash_algo, base_asym_algo, pqc_asym_algo, + requester_info, requester_info_length, + opaque_data, opaque_data_length, + csr_len, csr_pointer, is_device_cert_model); + return result; + } +} +#endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX*/ + +#endif /* LIBSPDM_ENABLE_CAPABILITY_CSR_CAP */ diff --git a/os_stub/spdm_device_secret_lib_tpm/keys.h b/os_stub/spdm_device_secret_lib_tpm/keys.h new file mode 100644 index 00000000000..34533f406b0 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/keys.h @@ -0,0 +1,25 @@ +/** + * Copyright Notice: + * Copyright 2024-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#pragma once + +#define TPM_ROOT_CTX 0x81000000 +#define TPM_ROOT_KEY 0x81000001 + +#define TPM_REQU_CTX 0x81000010 +#define TPM_REQU_KEY 0x81000011 +#define TPM_REQU_HANDLE "handle:0x81000011" + +#define TPM_RESP_CTX 0x81000020 +#define TPM_RESP_KEY 0x81000021 +#define TPM_RESP_HANDLE "handle:0x81000021" + +#define TPM_ROOT_CERT 0x1500000 +#define TPM_REQU_CERT 0x1500010 +#define TPM_RESP_CERT 0x1500020 + +#define TPM_REQU_CERT_CHAIN 0x1500011 +#define TPM_RESP_CERT_CHAIN 0x1500021 diff --git a/os_stub/spdm_device_secret_lib_tpm/lib.c b/os_stub/spdm_device_secret_lib_tpm/lib.c new file mode 100644 index 00000000000..c6558968c69 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/lib.c @@ -0,0 +1,145 @@ +/** + * Copyright Notice: + * Copyright 2021-2026 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: + * https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +/** @file + * SPDM common library. + * It follows the SPDM Specification. + **/ + +#include "hal/library/responder/asymsignlib.h" +#include "hal/library/responder/csrlib.h" +#include "hal/library/responder/key_pair_info.h" +#include "hal/library/responder/measlib.h" +#include "hal/library/responder/psklib.h" +#include "hal/library/responder/setcertlib.h" + +/** + * This file contains compatibility method stubs used in unit tests that are + * not supported by the TPM implementation. + */ + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_private_key(uint32_t base_asym_algo, void **data, + size_t *size) { + return false; +} +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || \ + (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_private_key(uint16_t req_base_asym_alg, void **data, + size_t *size) { + return false; +} +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_pqc_private_key(uint32_t pqc_asym_algo, void **data, + size_t *size) { + return false; +} +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || \ + (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_pqc_private_key(uint32_t req_pqc_asym_alg, + void **data, size_t *size) { + return false; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP || (...) */ + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool g_private_key_mode = 1; +#endif + +#if LIBSPDM_ECDSA_SUPPORT +uint8_t m_libspdm_ec256_responder_private_key[] = {}; +uint8_t m_libspdm_ec256_responder_public_key[] = {}; +uint8_t m_libspdm_ec384_responder_private_key[] = {}; +uint8_t m_libspdm_ec384_responder_public_key[] = {}; +uint8_t m_libspdm_ec521_responder_private_key[] = {}; +uint8_t m_libspdm_ec521_responder_public_key[] = {}; +uint8_t m_libspdm_ec256_requester_private_key[] = {}; +uint8_t m_libspdm_ec256_requester_public_key[] = {}; +uint8_t m_libspdm_ec384_requester_private_key[] = {}; +uint8_t m_libspdm_ec384_requester_public_key[] = {}; +uint8_t m_libspdm_ec521_requester_private_key[] = {}; +uint8_t m_libspdm_ec521_requester_public_key[] = {}; +#endif /*LIBSPDM_ECDSA_SUPPORT*/ + +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) +uint8_t m_libspdm_rsa2048_res_n[] = {}; +uint8_t m_libspdm_rsa2048_res_e[] = {}; +uint8_t m_libspdm_rsa2048_res_d[] = {}; +uint8_t m_libspdm_rsa3072_res_n[] = {}; +uint8_t m_libspdm_rsa3072_res_e[] = {}; +uint8_t m_libspdm_rsa3072_res_d[] = {}; +uint8_t m_libspdm_rsa4096_res_n[] = {}; +uint8_t m_libspdm_rsa4096_res_e[] = {}; +uint8_t m_libspdm_rsa4096_res_d[] = {}; +uint8_t m_libspdm_rsa2048_req_n[] = {}; +uint8_t m_libspdm_rsa2048_req_e[] = {}; +uint8_t m_libspdm_rsa2048_req_d[] = {}; +uint8_t m_libspdm_rsa3072_req_n[] = {}; +uint8_t m_libspdm_rsa3072_req_e[] = {}; +uint8_t m_libspdm_rsa3072_req_d[] = {}; +uint8_t m_libspdm_rsa4096_req_n[] = {}; +uint8_t m_libspdm_rsa4096_req_e[] = {}; +uint8_t m_libspdm_rsa4096_req_d[] = {}; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + +bool libspdm_get_responder_private_key_from_raw_data(uint32_t base_asym_algo, + void **context) { + return false; +} + +bool libspdm_get_requester_private_key_from_raw_data(uint32_t base_asym_algo, + void **context) { + return false; +} + +bool libspdm_get_responder_pqc_private_key_from_raw_data(uint32_t pqc_asym_algo, + void **context) { + return false; +} + +bool libspdm_get_requester_pqc_private_key_from_raw_data( + uint32_t req_pqc_asym_algo, void **context) { + return false; +} + +bool libspdm_read_responder_public_key(uint32_t base_asym_algo, void **data, + size_t *size) { + return false; +} + +bool libspdm_read_requester_public_key(uint16_t req_base_asym_alg, void **data, + size_t *size) { + return false; +} + +bool libspdm_read_responder_pqc_public_key(uint32_t pqc_asym_algo, void **data, + size_t *size) { + return false; +} + +bool libspdm_read_requester_pqc_public_key(uint32_t req_pqc_asym_alg, + void **data, size_t *size) { + return false; +} + +bool libspdm_read_responder_root_public_certificate_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t chain_id, + void **data, size_t *size, void **hash, size_t *hash_size) { + return false; +} + +bool libspdm_read_responder_public_certificate_chain_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t chain_id, + void **data, size_t *size, void **hash, size_t *hash_size) { + return false; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/meas.c b/os_stub/spdm_device_secret_lib_tpm/meas.c new file mode 100644 index 00000000000..f04a947b998 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/meas.c @@ -0,0 +1,808 @@ +/** + * Copyright Notice: + * Copyright 2024-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "internal/libspdm_common_lib.h" + +#if (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) + +#define LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE 0x1000 +uint8_t m_libspdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE]; + +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) */ + +#if (LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP) +void libspdm_generate_mel(uint32_t measurement_hash_algo) +{ + spdm_measurement_extension_log_dmtf_t *measurement_extension_log; + spdm_mel_entry_dmtf_t *mel_entry1; + spdm_mel_entry_dmtf_t *mel_entry2; + spdm_mel_entry_dmtf_t *mel_entry3; + + uint8_t rom_informational[] = "ROM"; + uint8_t bootfv_informational[] = "Boot FW"; + uint32_t version = 0x0100030A; + + /*generate MEL*/ + measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + + measurement_extension_log->number_of_entries = 3; + measurement_extension_log->mel_entries_len = + measurement_extension_log->number_of_entries * sizeof(spdm_mel_entry_dmtf_t) + + sizeof(rom_informational) - 1 + sizeof(bootfv_informational) - 1 + sizeof(version); + measurement_extension_log->reserved = 0; + + /*MEL Entry 1: informational ROM */ + mel_entry1 = (spdm_mel_entry_dmtf_t *)((uint8_t *)measurement_extension_log + + sizeof(spdm_measurement_extension_log_dmtf_t)); + mel_entry1->mel_index = 1; + mel_entry1->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM; + libspdm_write_uint24(mel_entry1->reserved, 0); + mel_entry1->measurement_block_dmtf_header.dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_INFORMATIONAL | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + mel_entry1->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = + sizeof(rom_informational) - 1; + libspdm_copy_mem((void *)(mel_entry1 + 1), sizeof(rom_informational) - 1, + rom_informational, sizeof(rom_informational) - 1); + + /*MEL Entry 2: informational Boot FW */ + mel_entry2 = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry1 + 1) + + sizeof(rom_informational) - 1); + mel_entry2->mel_index = 2; + mel_entry2->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM; + libspdm_write_uint24(mel_entry2->reserved, 0); + mel_entry2->measurement_block_dmtf_header.dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_INFORMATIONAL | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + mel_entry2->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = + sizeof(bootfv_informational) - 1; + libspdm_copy_mem((void *)(mel_entry2 + 1), sizeof(bootfv_informational) - 1, + bootfv_informational, sizeof(bootfv_informational) - 1); + + /*MEL Entry 3: version 0x0100030A */ + mel_entry3 = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry2 + 1) + + sizeof(bootfv_informational) - 1); + mel_entry3->mel_index = 3; + mel_entry3->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM; + libspdm_write_uint24(mel_entry3->reserved, 0); + mel_entry3->measurement_block_dmtf_header.dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_VERSION | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + mel_entry3->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = sizeof(version); + libspdm_copy_mem((void *)(mel_entry3 + 1), sizeof(version), &version, sizeof(version)); +} +#endif /*(LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP)*/ + +#if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP +/** + * Fill image hash measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_image_hash_block ( + bool use_bit_stream, + uint32_t measurement_hash_algo, + uint8_t measurements_index, + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + size_t hash_size; + void *buffer = NULL; + size_t buffer_size = 0; + + hash_size = libspdm_get_measurement_hash_size(measurement_hash_algo); + + if (use_bit_stream) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "use_bit_stream for image_hash_block for TMP device is not supported")); + return 0; + } + + measurement_block->measurement_block_common_header + .index = measurements_index; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + (measurements_index - 1); + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)hash_size; + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)hash_size); + + buffer = (uint8_t*)(measurement_block + 1); + buffer_size = 0; + if (!libspdm_tpm_read_pcr(measurement_hash_algo, measurements_index, buffer, &buffer_size)) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "failed to read pcr from TPM")); + return 0; + } + + if (buffer_size != hash_size) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "hash_size (%d) != buffer_size (%d)\n", hash_size, buffer_size)); + return 0; + } + + return sizeof(spdm_measurement_block_dmtf_t) + hash_size; +} + +/** + * Fill svn measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_svn_block ( + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + spdm_measurements_secure_version_number_t svn; + + measurement_block->measurement_block_common_header + .index = LIBSPDM_MEASUREMENT_INDEX_SVN; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + svn = 0x7; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_SECURE_VERSION_NUMBER | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)sizeof(svn); + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)sizeof(svn)); + + libspdm_copy_mem((void *)(measurement_block + 1), sizeof(svn), (void *)&svn, sizeof(svn)); + + return sizeof(spdm_measurement_block_dmtf_t) + sizeof(svn); +} + +/** + * Fill HEM measurement block. + * + * @param measurement_block A pointer to store measurement block. + * @param measurement_hash_algo Indicates the measurement hash algorithm. + * It must align with measurement_hash_alg + * (SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_*) + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_hem_block ( + spdm_measurement_block_dmtf_t *measurement_block, uint32_t measurement_hash_algo + ) +{ + size_t hash_size; + spdm_measurement_extension_log_dmtf_t *measurement_extension_log; + spdm_mel_entry_dmtf_t *mel_entry; + uint32_t index; + uint8_t *verify_hem; + + if (measurement_hash_algo == SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_RAW_BIT_STREAM_ONLY) { + return 0; + } + + libspdm_generate_mel(measurement_hash_algo); + + hash_size = libspdm_get_measurement_hash_size(measurement_hash_algo); + if (measurement_block == NULL) { + return sizeof(spdm_measurement_block_dmtf_t) + hash_size; + } + + /*MEL*/ + measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + + /*generate measurement block*/ + measurement_block->measurement_block_common_header + .index = LIBSPDM_MEASUREMENT_INDEX_HEM; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_HASH_EXTEND_MEASUREMENT; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)hash_size; + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)hash_size); + + verify_hem = malloc(measurement_extension_log->mel_entries_len + hash_size); + if (verify_hem == NULL) { + return 0; + } + + libspdm_zero_mem(verify_hem, measurement_extension_log->mel_entries_len + hash_size); + mel_entry = (spdm_mel_entry_dmtf_t *)((uint8_t *)measurement_extension_log + + sizeof(spdm_measurement_extension_log_dmtf_t)); + for (index = 0; index < measurement_extension_log->number_of_entries; index++) { + libspdm_copy_mem( + verify_hem + hash_size, + measurement_extension_log->mel_entries_len, + mel_entry, + sizeof(spdm_mel_entry_dmtf_t) + + mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size); + + if (!libspdm_measurement_hash_all( + measurement_hash_algo, + verify_hem, + hash_size + sizeof(spdm_mel_entry_dmtf_t) + + mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size, + verify_hem + )) { + free(verify_hem); + return 0; + } + mel_entry = (spdm_mel_entry_dmtf_t *) + ((uint8_t *)mel_entry + sizeof(spdm_mel_entry_dmtf_t)+ + mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size); + } + + libspdm_copy_mem((void *)(measurement_block + 1), hash_size, verify_hem, hash_size); + free(verify_hem); + return sizeof(spdm_measurement_block_dmtf_t) + hash_size; +} + +/** + * Fill manifest measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_manifest_block ( + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + uint8_t data[LIBSPDM_MEASUREMENT_MANIFEST_SIZE]; + + measurement_block->measurement_block_common_header + .index = SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_MEASUREMENT_MANIFEST; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + libspdm_set_mem(data, sizeof(data), + (uint8_t)SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_MEASUREMENT_MANIFEST); + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_MEASUREMENT_MANIFEST | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)sizeof(data); + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)sizeof(data)); + + libspdm_copy_mem((void *)(measurement_block + 1), sizeof(data), data, sizeof(data)); + + return sizeof(spdm_measurement_block_dmtf_t) + sizeof(data); +} + +/** + * Fill device mode measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_device_mode_block ( + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + spdm_measurements_device_mode_t device_mode; + + measurement_block->measurement_block_common_header + .index = SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_DEVICE_MODE; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + device_mode.operational_mode_capabilities = + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_MANUFACTURING_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_VALIDATION_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_NORMAL_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_RECOVERY_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_RMA_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_DECOMMISSIONED_MODE; + device_mode.operational_mode_state = + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_NORMAL_MODE; + device_mode.device_mode_capabilities = + SPDM_MEASUREMENT_DEVICE_MODE_NON_INVASIVE_DEBUG_MODE_IS_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_IS_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_NON_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE_AFTER_MFG; + device_mode.device_mode_state = + SPDM_MEASUREMENT_DEVICE_MODE_NON_INVASIVE_DEBUG_MODE_IS_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE_AFTER_MFG; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_DEVICE_MODE | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)sizeof(device_mode); + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)sizeof(device_mode)); + + libspdm_copy_mem((void *)(measurement_block + 1), sizeof(device_mode), + (void *)&device_mode, sizeof(device_mode)); + + return sizeof(spdm_measurement_block_dmtf_t) + sizeof(device_mode); +} + +bool g_check_measurement_request_context = false; +uint64_t g_measurement_request_context; + +libspdm_return_t libspdm_measurement_collection( + void *spdm_context, + const uint32_t *session_id, + spdm_version_number_t spdm_version, + uint8_t measurement_specification, + uint32_t measurement_hash_algo, + uint8_t measurements_index, + uint8_t request_attribute, + size_t request_context_size, + const void *request_context, + uint8_t *content_changed, + uint8_t *measurements_count, + void *measurements, + size_t *measurements_size) +{ + spdm_measurement_block_dmtf_t *measurement_block; + size_t hash_size; + uint8_t index; + size_t total_size_needed; + bool use_bit_stream; + size_t measurement_block_size; + + if ((measurement_specification != SPDM_MEASUREMENT_SPECIFICATION_DMTF) || + (measurement_hash_algo == 0)) { + return LIBSPDM_STATUS_UNSUPPORTED_CAP; + } + + if (g_check_measurement_request_context) { + if ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_13) { + LIBSPDM_ASSERT(request_context_size == SPDM_REQ_CONTEXT_SIZE); + LIBSPDM_ASSERT(libspdm_read_uint64(request_context) == g_measurement_request_context); + } else { + LIBSPDM_ASSERT(request_context_size == 0); + LIBSPDM_ASSERT(request_context == NULL); + } + } + + hash_size = libspdm_get_measurement_hash_size(measurement_hash_algo); + LIBSPDM_ASSERT(hash_size != 0); + + use_bit_stream = false; + if ((measurement_hash_algo == SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_RAW_BIT_STREAM_ONLY) || + ((request_attribute & SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_RAW_BIT_STREAM_REQUESTED) != + 0)) { + use_bit_stream = true; + } + + if (measurements_index == + SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_TOTAL_NUMBER_OF_MEASUREMENTS) { + *measurements_count = LIBSPDM_MEASUREMENT_BLOCK_NUMBER; + goto successful_return; + } else if (measurements_index == + SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_ALL_MEASUREMENTS) { + + /* Calculate total_size_needed based on hash algo selected. + * If we have an hash algo, then the first HASH_NUMBER elements will be + * hash values, otherwise HASH_NUMBER raw bitstream values.*/ + if (!use_bit_stream) { + total_size_needed = + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER * + (sizeof(spdm_measurement_block_dmtf_t) + hash_size); + } else { + total_size_needed = + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER * + (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_RAW_DATA_SIZE); + } + /* Next one - SVN is always raw bitstream data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + + sizeof(spdm_measurements_secure_version_number_t)); + /* Next one - HEM is always digest data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + hash_size); + /* Next one - manifest is always raw bitstream data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_MANIFEST_SIZE); + /* Next one - device_mode is always raw bitstream data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + sizeof(spdm_measurements_device_mode_t)); + + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_size = total_size_needed; + *measurements_count = LIBSPDM_MEASUREMENT_BLOCK_NUMBER; + measurement_block = measurements; + + /* The first HASH_NUMBER blocks may be hash values or raw bitstream*/ + for (index = 1; index <= LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER; index++) { + measurement_block_size = libspdm_fill_measurement_image_hash_block (use_bit_stream, + measurement_hash_algo, + index, + measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - SVN is always raw bitstream data.*/ + { + measurement_block_size = libspdm_fill_measurement_svn_block (measurement_block); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - HEM is always digest data.*/ + { + measurement_block_size = libspdm_fill_measurement_hem_block (measurement_block, + measurement_hash_algo); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - manifest is always raw bitstream data.*/ + { + measurement_block_size = libspdm_fill_measurement_manifest_block (measurement_block); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - device_mode is always raw bitstream data.*/ + { + measurement_block_size = libspdm_fill_measurement_device_mode_block (measurement_block); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + + goto successful_return; + } else { + /* One Index */ + if (measurements_index <= LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER) { + if (!use_bit_stream) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + hash_size; + } else { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + LIBSPDM_MEASUREMENT_RAW_DATA_SIZE; + } + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_image_hash_block (use_bit_stream, + measurement_hash_algo, + measurements_index, + measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == LIBSPDM_MEASUREMENT_INDEX_SVN) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + sizeof(spdm_measurements_secure_version_number_t); + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_svn_block (measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == LIBSPDM_MEASUREMENT_INDEX_HEM) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + hash_size; + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_hem_block (measurement_block, + measurement_hash_algo); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_MEASUREMENT_MANIFEST) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + LIBSPDM_MEASUREMENT_MANIFEST_SIZE; + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_manifest_block (measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_DEVICE_MODE) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + sizeof(spdm_measurements_device_mode_t); + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_device_mode_block (measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else { + *measurements_count = 0; + return LIBSPDM_STATUS_MEAS_INVALID_INDEX; + } + } + +successful_return: + if ((content_changed != NULL) && + ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_12)) { + /* return content change*/ + if ((request_attribute & SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) != + 0) { + *content_changed = SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED; + } else { + *content_changed = SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_NO_DETECTION; + } + } + + return LIBSPDM_STATUS_SUCCESS; +} + +size_t libspdm_secret_lib_meas_opaque_data_size; + +bool libspdm_measurement_opaque_data( + void *spdm_context, + const uint32_t *session_id, + spdm_version_number_t spdm_version, + uint8_t measurement_specification, + uint32_t measurement_hash_algo, + uint8_t measurement_index, + uint8_t request_attribute, + size_t request_context_size, + const void *request_context, + void *opaque_data, + size_t *opaque_data_size) +{ + size_t index; + + LIBSPDM_ASSERT(libspdm_secret_lib_meas_opaque_data_size <= *opaque_data_size); + + if (g_check_measurement_request_context) { + if ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_13) { + LIBSPDM_ASSERT(request_context_size == SPDM_REQ_CONTEXT_SIZE); + LIBSPDM_ASSERT(libspdm_read_uint64(request_context) == g_measurement_request_context); + } else { + LIBSPDM_ASSERT(request_context_size == 0); + LIBSPDM_ASSERT(request_context == NULL); + } + } + + *opaque_data_size = libspdm_secret_lib_meas_opaque_data_size; + + for (index = 0; index < *opaque_data_size; index++) + { + ((uint8_t *)opaque_data)[index] = (uint8_t)index; + } + + return true; +} + +#ifndef LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE +#define LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE 0x1000 +#endif + +bool libspdm_generate_measurement_summary_hash( + void *spdm_context, + spdm_version_number_t spdm_version, uint32_t base_hash_algo, + uint8_t measurement_specification, uint32_t measurement_hash_algo, + uint8_t measurement_summary_hash_type, + uint8_t *measurement_summary_hash, + uint32_t measurement_summary_hash_size) +{ + uint8_t measurement_data[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE]; + size_t index; + spdm_measurement_block_dmtf_t *cached_measurement_block; + size_t measurement_data_size; + size_t measurement_block_size; + uint8_t device_measurement[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE]; + uint8_t device_measurement_count; + size_t device_measurement_size; + libspdm_return_t status; + bool result; + + switch (measurement_summary_hash_type) { + case SPDM_REQUEST_NO_MEASUREMENT_SUMMARY_HASH: + return false; + + case SPDM_REQUEST_TCB_COMPONENT_MEASUREMENT_HASH: + case SPDM_REQUEST_ALL_MEASUREMENTS_HASH: + if (measurement_summary_hash_size != libspdm_get_hash_size(base_hash_algo)) { + return false; + } + + /* get all measurement data*/ + device_measurement_size = sizeof(device_measurement); + status = libspdm_measurement_collection( + spdm_context, + NULL, + spdm_version, measurement_specification, + measurement_hash_algo, + 0xFF, /* Get all measurements*/ + 0, + 0, + NULL, + NULL, + &device_measurement_count, device_measurement, + &device_measurement_size); + if (LIBSPDM_STATUS_IS_ERROR(status)) { + return false; + } + + /* double confirm that MeasurementData internal size is correct*/ + measurement_data_size = 0; + cached_measurement_block = (void *)device_measurement; + for (index = 0; index < device_measurement_count; index++) { + measurement_block_size = + sizeof(spdm_measurement_block_common_header_t) + + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + LIBSPDM_ASSERT(cached_measurement_block + ->measurement_block_common_header + .measurement_size == + sizeof(spdm_measurement_block_dmtf_header_t) + + cached_measurement_block + ->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size); + measurement_data_size += + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + cached_measurement_block = + (void *)((size_t)cached_measurement_block + + measurement_block_size); + } + + LIBSPDM_ASSERT(measurement_data_size <= + LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE); + + /* get required data and hash them*/ + cached_measurement_block = (void *)device_measurement; + measurement_data_size = 0; + for (index = 0; index < device_measurement_count; index++) { + measurement_block_size = + sizeof(spdm_measurement_block_common_header_t) + + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + /* filter unneeded data*/ + if ((measurement_summary_hash_type == + SPDM_REQUEST_ALL_MEASUREMENTS_HASH) || + ((cached_measurement_block + ->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type & + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_MASK) == + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_IMMUTABLE_ROM)) { + libspdm_copy_mem(&measurement_data[measurement_data_size], + sizeof(measurement_data) + - (&measurement_data[measurement_data_size] - measurement_data), + cached_measurement_block, + sizeof(cached_measurement_block-> + measurement_block_common_header) + + cached_measurement_block->measurement_block_common_header + .measurement_size); + measurement_data_size += + sizeof(cached_measurement_block->measurement_block_common_header) + + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + } + cached_measurement_block = + (void *)((size_t)cached_measurement_block + + measurement_block_size); + } + + result = libspdm_hash_all(base_hash_algo, measurement_data, + measurement_data_size, measurement_summary_hash); + if (!result) { + return false; + } + break; + default: + return false; + break; + } + return true; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */ + +#if LIBSPDM_ENABLE_CAPABILITY_MEL_CAP +/*Collect the measurement extension log.*/ +bool libspdm_measurement_extension_log_collection( + void *spdm_context, + uint8_t mel_specification, + uint8_t measurement_specification, + uint32_t measurement_hash_algo, + void **spdm_mel, + size_t *spdm_mel_size) +{ + spdm_measurement_extension_log_dmtf_t *measurement_extension_log; + + if ((measurement_specification != + SPDM_MEASUREMENT_SPECIFICATION_DMTF) || + (mel_specification != SPDM_MEL_SPECIFICATION_DMTF) || + (measurement_hash_algo == 0)) { + return false; + } + + libspdm_generate_mel(measurement_hash_algo); + + measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + *spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + *spdm_mel_size = (size_t)(measurement_extension_log->mel_entries_len) + + sizeof(spdm_measurement_extension_log_dmtf_t); + return true; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP */ diff --git a/os_stub/spdm_device_secret_lib_tpm/read_pub_cert.c b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert.c new file mode 100644 index 00000000000..c8f5c3325b1 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert.c @@ -0,0 +1,238 @@ +/** + * Copyright Notice: + * Copyright 2021-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" +#include "spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "keys.h" + +static bool get_certificate(uint32_t index, uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + bool result; + void *cert; + size_t cert_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + size_t digest_size; + + if (!libspdm_tpm_device_init()) + return false; + + result = libspdm_tpm_read_nv(index, &cert, &cert_size); + if (!result) + return false; + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + cert_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL){ + result = false; + goto cleanup_cert; + } + cert_chain->length = (uint32_t)cert_chain_size; + + result = libspdm_hash_all(base_hash_algo, cert, cert_size, + (uint8_t *)(cert_chain + 1)); + if (!result){ + result = false; + free(cert_chain); + goto cleanup_cert; + } + + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + cert, cert_size); + + *data = cert_chain; + *size = cert_chain_size; + + if (hash != NULL) + *hash = (cert_chain + 1); + + if (hash_size != NULL) + *hash_size = digest_size; + +cleanup_cert: + free(cert); + + return result; +} + +static bool get_certificate_chain(uint32_t index, uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size, + bool is_requester_cert, bool is_device_cert_model) +{ + bool result; + void *cert; + size_t cert_size; + const uint8_t *root_cert; + size_t root_cert_len; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + size_t digest_size; + + if (!libspdm_tpm_read_nv(index, &cert, &cert_size)){ + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "failed to read nv index %d\n", index)); + return false; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + cert_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL){ + result = false; + goto cleanup_cert; + } + cert_chain->length = (uint32_t)cert_chain_size; + result = libspdm_verify_cert_chain_data(SPDM_MESSAGE_VERSION_12, + cert, cert_size, + base_asym_algo, 0, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!result) + goto cleanup_cert_chain; + + result = libspdm_x509_get_cert_from_cert_chain(cert, cert_size, 0, &root_cert, + &root_cert_len); + if (!result) + goto cleanup_cert_chain; + + result = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!result) + goto cleanup_cert_chain; + + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + cert, cert_size); + + *data = cert_chain; + *size = cert_chain_size; + + if (hash != NULL) + *hash = (cert_chain + 1); + + if (hash_size != NULL) + *hash_size = digest_size; + + if (result) + goto cleanup_cert; + +cleanup_cert_chain: + free(cert_chain); + +cleanup_cert: + free(cert); + + return result; +} + +bool libspdm_read_requester_root_public_certificate(uint32_t base_hash_algo, + uint16_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + return get_certificate(TPM_ROOT_CERT, base_hash_algo, base_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_requester_public_certificate_chain( + uint32_t base_hash_algo, uint16_t req_base_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + return get_certificate_chain(TPM_REQU_CERT_CHAIN, base_hash_algo, req_base_asym_alg, data, size, hash, + hash_size, false, true); +} + +bool libspdm_read_responder_certificate(uint32_t base_asym_algo, + void **data, size_t *size) +{ + bool result; + void *cert; + size_t cert_size; + + if (base_asym_algo != SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256){ + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "unsupported asym algo %d\n", base_asym_algo)); + return false; + } + + if (!libspdm_tpm_device_init()) + return false; + + result = libspdm_tpm_read_nv(TPM_RESP_CERT, &cert, &cert_size); + if (!result) + return false; + + return true; +} + +bool libspdm_read_responder_root_public_certificate(uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + return get_certificate(TPM_ROOT_CERT, base_hash_algo, base_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + return get_certificate_chain(TPM_RESP_CERT_CHAIN, base_hash_algo, base_asym_algo, data, size, hash, hash_size, + false, true); +} + +bool libspdm_read_responder_root_public_certificate_slot(uint8_t slot_id, + uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + return get_certificate(TPM_ROOT_CERT, base_hash_algo, base_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t base_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size) +{ + return get_certificate_chain(TPM_RESP_CERT_CHAIN, base_hash_algo, base_asym_algo, data, size, hash, hash_size, + false, true); +} + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + libspdm_debug_print(LIBSPDM_DEBUG_ERROR, + "libspdm_read_responder_public_certificate_chain_alias_cert_till_dev_cert_ca not yet implemented\n"); + return false; +} + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + libspdm_debug_print(LIBSPDM_DEBUG_ERROR, + "libspdm_read_responder_public_certificate_chain_alias_cert not yet implemented\n"); + return false; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/read_pub_cert_pqc.c b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert_pqc.c new file mode 100644 index 00000000000..74a025f8cdd --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert_pqc.c @@ -0,0 +1,86 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: + * https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "library/debuglib.h" +#include "library/memlib.h" +#include "spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "spdm_device_secret_lib_internal.h" +#include + +bool libspdm_read_pqc_responder_root_public_certificate( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, size_t *size, + void **hash, size_t *hash_size) { + /* TPM API need no changes for pqc support */ + return libspdm_read_requester_root_public_certificate( + base_hash_algo, pqc_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_pqc_responder_root_public_certificate_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t pqc_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size) { + return libspdm_read_responder_root_public_certificate_slot( + slot_id, base_hash_algo, pqc_asym_algo, data, size, hash, hash_size); + ; +} + +bool libspdm_read_pqc_requester_root_public_certificate( + uint32_t base_hash_algo, uint32_t req_pqc_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size) { + return libspdm_read_requester_root_public_certificate( + base_hash_algo, req_pqc_asym_alg, data, size, hash, hash_size); +} + +bool libspdm_read_pqc_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, size_t *size, + void **hash, size_t *hash_size) { + return libspdm_read_responder_public_certificate_chain( + base_hash_algo, pqc_asym_algo, data, size, hash, hash_size); +} + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, size_t *size, + void **hash, size_t *hash_size) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "not supported")); + return false; +} + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, size_t *size, + void **hash, size_t *hash_size) { + return libspdm_read_responder_public_certificate_chain_alias_cert( + base_hash_algo, pqc_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_pqc_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t pqc_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size) { + return libspdm_read_responder_public_certificate_chain_per_slot( + slot_id, base_hash_algo, pqc_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_pqc_requester_public_certificate_chain( + uint32_t base_hash_algo, uint32_t req_pqc_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size) { + return libspdm_read_requester_public_certificate_chain( + base_hash_algo, req_pqc_asym_alg, data, size, hash, hash_size); +} + +bool libspdm_read_responder_pqc_certificate(uint32_t pqc_asym_algo, void **data, + size_t *size) { + return libspdm_read_responder_certificate(pqc_asym_algo, data, size); +} diff --git a/os_stub/spdm_device_secret_lib_tpm/sign.c b/os_stub/spdm_device_secret_lib_tpm/sign.c new file mode 100644 index 00000000000..c2503ab69a1 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/sign.c @@ -0,0 +1,91 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/debuglib.h" +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "internal/libspdm_common_lib.h" +#include "keys.h" + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_requester_data_sign( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t key_pair_id, uint8_t op_code, + uint16_t req_base_asym_alg, uint32_t req_pqc_asym_alg, + uint32_t base_hash_algo, bool is_data_hash, + const uint8_t *message, size_t message_size, + uint8_t *signature, size_t *sig_size) +{ + void *context = NULL; + bool result = false; + + libspdm_debug_print(LIBSPDM_DEBUG_INFO, "Loading TPM device"); + libspdm_tpm_device_init(); + result = libspdm_tpm_get_private_key(TPM_REQU_HANDLE, &context); + if (!result){ + libspdm_debug_print(LIBSPDM_DEBUG_ERROR, "Failed to load requester handle"); + return false; + } + + if (is_data_hash){ + result = libspdm_req_asym_sign_hash( + spdm_version, op_code, req_base_asym_alg, base_hash_algo, context, + message, message_size, signature, sig_size); + } else { + result = libspdm_req_asym_sign(spdm_version, op_code, req_base_asym_alg, + base_hash_algo, context, message, + message_size, signature, sig_size); + } + libspdm_asym_free(req_base_asym_alg, context); + + return result; +} +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ + +bool libspdm_responder_data_sign( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t key_pair_id, uint8_t op_code, + uint32_t base_asym_algo, uint32_t pqc_asym_algo, + uint32_t base_hash_algo, bool is_data_hash, + const uint8_t *message, size_t message_size, + uint8_t *signature, size_t *sig_size) +{ + void *context = NULL; + bool result = false; + + libspdm_tpm_device_init(); + result = libspdm_tpm_get_private_key(TPM_RESP_HANDLE, &context); + if (!result){ + libspdm_debug_print(LIBSPDM_DEBUG_ERROR, "Failed to load responder handle"); + return false; + } + + if (is_data_hash){ + result = libspdm_asym_sign_hash(spdm_version, op_code, base_asym_algo, + base_hash_algo, context, message, + message_size, signature, sig_size); + } else { + result = + libspdm_asym_sign(spdm_version, op_code, base_asym_algo, base_hash_algo, + context, message, message_size, signature, sig_size); + } + libspdm_asym_free(base_asym_algo, context); + + return result; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/spdm_device_secret_lib_internal.h b/os_stub/spdm_device_secret_lib_tpm/spdm_device_secret_lib_internal.h new file mode 100644 index 00000000000..fef326c5909 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/spdm_device_secret_lib_internal.h @@ -0,0 +1,231 @@ +/** + * Copyright Notice: + * Copyright 2021-2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#ifndef __SPDM_DEVICE_SECRET_LIB_INTERNAL_H__ +#define __SPDM_DEVICE_SECRET_LIB_INTERNAL_H__ + +#include "library/spdm_crypt_lib.h" +#include "spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "spdm_crypt_ext_lib/cryptlib_ext.h" +#include "hal/library/responder/asymsignlib.h" +#include "hal/library/responder/csrlib.h" +#include "hal/library/responder/measlib.h" +#include "hal/library/responder/key_pair_info.h" +#include "hal/library/responder/psklib.h" +#include "hal/library/responder/setcertlib.h" +#include "hal/library/requester/reqasymsignlib.h" +#include "hal/library/requester/psklib.h" +#include "hal/library/debuglib.h" +#include "hal/library/cryptlib.h" +#include "industry_standard/cxl_tsp.h" + +/* for meas test */ +#define LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER 4 +#define LIBSPDM_MEASUREMENT_BLOCK_NUMBER (LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER /*Index - 1~4*/ + \ + 1 /*SVN - 0x10*/ + \ + 1 /*HEM - 0x11*/ + \ + 1 /*Manifest - 0xFD*/ + 1 /*DEVICE_MODE - 0xFE*/) +#define LIBSPDM_MEASUREMENT_RAW_DATA_SIZE 72 +#define LIBSPDM_MEASUREMENT_MANIFEST_SIZE 128 +#define LIBSPDM_MEASUREMENT_INDEX_SVN 0x10 +#define LIBSPDM_MEASUREMENT_INDEX_HEM 0x11 + +/* for psk test */ +#define LIBSPDM_TEST_PSK_DATA_STRING "TestPskData" +#define LIBSPDM_TEST_PSK_HINT_STRING "TestPskHint" + +/* for cert test */ +#define LIBSPDM_TEST_CERT_MAXINT16 1 +#define LIBSPDM_TEST_CERT_MAXUINT16 2 +#define LIBSPDM_LIBSPDM_TEST_CERT_MAXUINT16_LARGER 3 +#define LIBSPDM_TEST_CERT_SMALL 4 + +/* "LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY = 1" means use the RAW private key only + * "LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY = 0" means controlled by g_private_key_mode + **/ +#define LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY 0 +/* "g_private_key_mode = 1" means use the PEM mode + * "g_private_key_mode = 0" means use the RAW mode + **/ +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +extern bool g_private_key_mode; +#endif + +/* Option to change signing algorithm to little endian. Default is big endian. */ +#define LIBSPDM_SECRET_LIB_SIGN_LITTLE_ENDIAN (0) + +/* read pub cert */ + +bool libspdm_read_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t base_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_requester_public_certificate_chain( + uint32_t base_hash_algo, uint16_t req_base_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_responder_root_public_certificate(uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_responder_root_public_certificate_slot(uint8_t slot_id, + uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_requester_root_public_certificate(uint32_t base_hash_algo, + uint16_t req_base_asym_alg, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_responder_certificate(uint32_t base_asym_algo, + void **data, size_t *size); + +/* read pub cert pqc */ + +bool libspdm_read_pqc_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_pqc_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t pqc_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_pqc_requester_public_certificate_chain( + uint32_t base_hash_algo, uint32_t req_pqc_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_pqc_responder_root_public_certificate(uint32_t base_hash_algo, + uint32_t pqc_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_pqc_responder_root_public_certificate_slot(uint8_t slot_id, + uint32_t base_hash_algo, + uint32_t pqc_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_pqc_requester_root_public_certificate(uint32_t base_hash_algo, + uint32_t req_pqc_asym_alg, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_responder_pqc_certificate(uint32_t base_asym_algo, + void **data, size_t *size); + +/* read special cert */ + +bool libspdm_read_responder_public_certificate_chain_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t CertId, + void **data, size_t *size, void **hash, + size_t *hash_size); + +bool libspdm_read_responder_root_public_certificate_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t CertId, + void **data, size_t *size, void **hash, + size_t *hash_size); + +/* read pub key der */ + +bool libspdm_read_responder_public_key( + uint32_t base_asym_algo, void **data, size_t *size); + +bool libspdm_read_requester_public_key( + uint16_t req_base_asym_alg, void **data, size_t *size); + +/* read pub key der pqc */ + +bool libspdm_read_responder_pqc_public_key( + uint32_t pqc_asym_algo, void **data, size_t *size); + +bool libspdm_read_requester_pqc_public_key( + uint32_t req_pqc_asym_alg, void **data, size_t *size); + +/* read priv key pem */ + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_private_key(uint32_t base_asym_algo, + void **data, size_t *size); +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_private_key(uint16_t req_base_asym_alg, + void **data, size_t *size); +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ + +/* read priv key pem pqc */ + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_pqc_private_key(uint32_t pqc_asym_algo, + void **data, size_t *size); +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_pqc_private_key(uint32_t req_pqc_asym_alg, + void **data, size_t *size); +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ + +/* read priv key raw data */ + +bool libspdm_get_responder_private_key_from_raw_data(uint32_t base_asym_algo, void **context); + +bool libspdm_get_requester_private_key_from_raw_data(uint32_t base_asym_algo, void **context); + +/* read priv key raw data pqc */ + +bool libspdm_get_responder_pqc_private_key_from_raw_data(uint32_t pqc_asym_algo, void **context); + +bool libspdm_get_requester_pqc_private_key_from_raw_data(uint32_t req_pqc_asym_algo, void **context); + +/* key pairs */ +#if LIBSPDM_ENABLE_CAPABILITY_GET_KEY_PAIR_INFO_CAP +uint8_t libspdm_read_total_key_pairs(void *spdm_context); +#endif + +/* External*/ + +bool libspdm_read_input_file(const char *file_name, void **file_data, + size_t *file_size); + +bool libspdm_write_output_file(const char *file_name, const void *file_data, + size_t file_size); + +void libspdm_dump_hex_str(const uint8_t *buffer, size_t buffer_size); + +#endif diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_challenge/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_challenge/CMakeLists.txt index 426fb49baee..e75dd52a978 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_challenge/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_challenge/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_challenge ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_challenge ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_get/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_get/CMakeLists.txt index fb6af57908a..154b2bba821 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_get/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_get/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_chunk_get ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_get ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_send/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_send/CMakeLists.txt index b6a4bfd47b6..dbab9be3f9d 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_send/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_send/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_chunk_send ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_chunk_send ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_certificate/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_certificate/CMakeLists.txt index 64fd8dd49f4..1c0e1b4bffe 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_certificate/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_encap_certificate ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_encap_certificate ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_challenge_auth/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_challenge_auth/CMakeLists.txt index 0fc61fcbebd..029321c2c3a 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_challenge_auth/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_challenge_auth/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_encap_challenge_auth ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_encap_challenge_auth ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_digests/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_digests/CMakeLists.txt index 3ab2e513a04..85b243fbd4c 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_digests/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_digests/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_encap_digests ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_encap_digests ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_key_update/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_key_update/CMakeLists.txt index 47cf72124f5..7211c46e28d 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_key_update/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_key_update/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_encap_key_update ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_encap_key_update ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_request/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_request/CMakeLists.txt index 0ad800a854c..1ca61444670 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_encap_request/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_encap_request/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_encap_request ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_encap_request ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_end_session/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_end_session/CMakeLists.txt index 884c32b6f68..ae71c16de03 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_end_session/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_end_session/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_end_session ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_end_session ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common @@ -45,7 +45,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_finish/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_finish/CMakeLists.txt index 176441e5b86..80b9b136935 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_finish/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_finish/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_finish ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_finish ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_get_certificate/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_get_certificate/CMakeLists.txt index c56a2e89a33..d8151471510 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_get_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_get_certificate/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_get_certificate ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_get_certificate ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_get_csr/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_get_csr/CMakeLists.txt index 964a399774e..fa099a3a2dc 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_get_csr/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_get_csr/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_get_csr ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_get_csr ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_get_digests/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_get_digests/CMakeLists.txt index f3d482c051b..a51ce6697bf 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_get_digests/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_get_digests/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_get_digests ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_get_digests ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_get_event_types/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_get_event_types/CMakeLists.txt index a0d7783952f..a17ab137c39 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_get_event_types/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_get_event_types/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_get_event_types ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_get_event_types ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_get_measurements/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_get_measurements/CMakeLists.txt index b18e0bc694a..634ce48474b 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_get_measurements/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_get_measurements/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_get_measurements ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_get_measurements ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_heartbeat/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_heartbeat/CMakeLists.txt index 4d13004365f..8585b1dfd5e 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_heartbeat/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_heartbeat/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_heartbeat ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_heartbeat ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt index 2bbb9392184..1d0097fdee4 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_key_exchange ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt index 208d8598fad..56c6859863c 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_key_update ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_key_update ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt index c6c9e861e4e..8db092159c0 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_negotiate_algorithms ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_requester_negotiate_algorithms @@ -61,6 +61,6 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt index 63c2ca97073..a3b26db46cc 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_psk_exchange ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt index a95fe21ed7e..956426fa814 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_psk_finish ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt index fcc6db22af5..df5bf29e8d2 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_set_certificate ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt index df1be3b0385..64f53d3b458 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_vendor_cmds ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt index 93693498a18..a19a9df670f 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_certificate ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_challenge_auth/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_challenge_auth/CMakeLists.txt index 222b6b2c699..df08ed42fb4 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_challenge_auth/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_challenge_auth/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_challenge_auth ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt index 069e1655bb3..14de85b8ccd 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_chunk_get ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt index f805433b00d..f877390be5f 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_chunk_send_ack ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt index 8ed364b4fdb..eb110295291 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_csr ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt index cd7eb3b48d2..a6ee1eb6f23 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_challenge ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt index 41ef018ac9d..05cd1274a4f 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_get_certificate ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt index 9587706859a..87eaf20f56e 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_get_digests ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt index b17e8e6b1e0..01174e1ecc0 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_key_update ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt index bce20f7ba85..8ba13e2ac12 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_response ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt index b2c8280fb8d..2d742e70c40 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_end_session ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt index b2ff7982195..557e1032b8e 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_finish_rsp ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt index 9ae072c84f1..c8f20b81c43 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_heartbeat_ack ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt index 6989e8690da..041287bdf2d 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_if_ready ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt index af732eef19d..4d803914534 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_key_exchange ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt index 27ce4cf4ebc..72ebee2bee2 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt @@ -8,7 +8,7 @@ target_include_directories(test_spdm_responder_key_pair_info ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub ) @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_responder_key_pair_info @@ -61,6 +61,6 @@ else() spdm_secured_message_lib spdm_transport_test_lib platform_lib_null - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt index a909b370e8d..9d9cea39a10 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_key_update ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt index 88e9b84db3e..8c0fced9769 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt @@ -42,7 +42,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_responder_measurement_extension_log @@ -60,6 +60,6 @@ else() spdm_secured_message_lib spdm_transport_test_lib platform_lib_null - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt index fce3c7ed151..4f90f5fdafc 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt @@ -8,7 +8,7 @@ target_include_directories(test_spdm_responder_measurements ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub ) @@ -42,7 +42,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -61,7 +61,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt index 3c6d667c673..c7ad0964c8b 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_psk_exchange_rsp ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt index b3b18428112..6b5e653c6e0 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_psk_finish_rsp ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt index d45a4181820..809039da881 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_set_certificate ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt index a6b05d614c1..0b4f2a0666b 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt @@ -8,7 +8,7 @@ target_include_directories(test_spdm_responder_set_key_pair_info_ack ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub ) @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_responder_set_key_pair_info_ack @@ -61,6 +61,6 @@ else() spdm_secured_message_lib spdm_transport_test_lib platform_lib_null - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt index a11a85a8122..18877096870 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt @@ -41,7 +41,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -60,7 +60,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt index 394203f1444..60e2ccbcac9 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt @@ -41,7 +41,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -60,7 +60,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/test_spdm_common/CMakeLists.txt b/unit_test/test_spdm_common/CMakeLists.txt index 718a5e9936e..9a2deac504c 100644 --- a/unit_test/test_spdm_common/CMakeLists.txt +++ b/unit_test/test_spdm_common/CMakeLists.txt @@ -8,7 +8,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) ${LIBSPDM_DIR}/unit_test/test_spdm_requester ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -39,7 +39,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) spdm_crypt_lib spdm_crypt_ext_lib spdm_secured_message_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_transport_test_lib cmockalib platform_lib_null diff --git a/unit_test/test_spdm_crypt/CMakeLists.txt b/unit_test/test_spdm_crypt/CMakeLists.txt index a459105abd8..038d4aef1db 100644 --- a/unit_test/test_spdm_crypt/CMakeLists.txt +++ b/unit_test/test_spdm_crypt/CMakeLists.txt @@ -6,7 +6,7 @@ target_include_directories(test_spdm_crypt PRIVATE ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -53,7 +53,7 @@ else() rnglib malloclib cmockalib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_crypt_ext_lib ) endif() diff --git a/unit_test/test_spdm_fips/CMakeLists.txt b/unit_test/test_spdm_fips/CMakeLists.txt index 8b9e5fe06d6..9f99e5386a7 100644 --- a/unit_test/test_spdm_fips/CMakeLists.txt +++ b/unit_test/test_spdm_fips/CMakeLists.txt @@ -6,7 +6,7 @@ target_include_directories(test_spdm_fips PRIVATE ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -53,6 +53,6 @@ else() rnglib malloclib cmockalib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() \ No newline at end of file diff --git a/unit_test/test_spdm_requester/CMakeLists.txt b/unit_test/test_spdm_requester/CMakeLists.txt index 8f24ba74c8a..f1d158f1051 100644 --- a/unit_test/test_spdm_requester/CMakeLists.txt +++ b/unit_test/test_spdm_requester/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester ${LIBSPDM_DIR}/unit_test/test_spdm_requester ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -99,7 +99,7 @@ target_link_libraries(test_spdm_requester $ $ $ - $ + $ $ $ $ @@ -119,7 +119,7 @@ else() spdm_crypt_lib spdm_crypt_ext_lib spdm_secured_message_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_transport_test_lib cmockalib platform_lib diff --git a/unit_test/test_spdm_responder/CMakeLists.txt b/unit_test/test_spdm_responder/CMakeLists.txt index 070470793ce..279075b85a4 100644 --- a/unit_test/test_spdm_responder/CMakeLists.txt +++ b/unit_test/test_spdm_responder/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_responder ${LIBSPDM_DIR}/unit_test/test_spdm_responder ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -89,7 +89,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ $ @@ -109,7 +109,7 @@ else() spdm_crypt_lib spdm_crypt_ext_lib spdm_secured_message_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_transport_test_lib cmockalib platform_lib diff --git a/unit_test/test_spdm_sample/CMakeLists.txt b/unit_test/test_spdm_sample/CMakeLists.txt index d353ad56dc1..2984916f42b 100644 --- a/unit_test/test_spdm_sample/CMakeLists.txt +++ b/unit_test/test_spdm_sample/CMakeLists.txt @@ -6,7 +6,7 @@ target_include_directories(test_spdm_sample PRIVATE ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/spdm_cert_verify_callback_sample ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery @@ -54,7 +54,7 @@ else() rnglib malloclib cmockalib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_cert_verify_callback_sample spdm_crypt_ext_lib spdm_common_lib diff --git a/unit_test/test_spdm_secured_message/CMakeLists.txt b/unit_test/test_spdm_secured_message/CMakeLists.txt index 629784b68af..fc65a60fbd3 100644 --- a/unit_test/test_spdm_secured_message/CMakeLists.txt +++ b/unit_test/test_spdm_secured_message/CMakeLists.txt @@ -8,7 +8,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) ${LIBSPDM_DIR}/unit_test/test_spdm_requester ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -38,7 +38,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) spdm_crypt_lib spdm_crypt_ext_lib spdm_secured_message_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_transport_test_lib cmockalib platform_lib_null